防止从子类访问实例变量，而不影响基类

Question

假设我有一个简单的类Foo，它来自外部库，因此我无法直接更改它：

class Foo(object):
    def __init__(self, x):
        self.x = x

我想创建一个子类Bar 并防止x 从Bar 的实例更改，但仍使用Bar 的方法中的x。

这是我尝试过的，它可能会启发基本思想，但不幸的是它不起作用：

class Bar(Foo):

    @property
    def x(self):
        return super().x

    @x.setter
    def x(self, value):
        raise NotImplementedError('Do not change x directly, use "do_stuff()" instead')

    def do_stuff(self, value):
        if <something>:
            super().x = value

所以基本上我已经围绕一个属性创建了一些包装函数 (do_stuff())，现在我想防止直接更改该属性，因为它可能会弄乱包装函数的某些功能。这是否可能以合理的方式进行？

编辑用一个更好的例子来说明我想要什么。我并不是要阻止他们看到变量 x，而是从 do_stuff() 之外更改它

Answer 1

如果您愿意完全避免继承，这应该更容易实现：

def main():
    bar = Bar(123)
    bar.fizz()
    bar.buzz()
    bar.fizz()
    bar.set_x(456)
    print('bar.x =', bar.x)
    try:
        bar.x = 123
    except AttributeError:
        print('bar.x cannot be set directly')
    else:
        raise AssertionError('an AttributeError should have been raised')
    bar.mutate_x(789)
    bar.fizz()
    bar.set_x(0)
    bar.fizz()
    bar.mutate_x(1)
    bar.fizz()
    bar.set_x('Hello World')
    bar.fizz()


class Foo:

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

    def fizz(self):
        print(self.x)

    def buzz(self):
        self.x = None


class Bar:

    def __init__(self, x):
        self.__foo = foo = Foo(x)
        self.__copy_methods(foo)

    def __copy_methods(self, obj):
        for name in dir(obj):
            if name.startswith('__') or name.endswith('__'):
                continue
            attr = getattr(obj, name)
            if callable(attr):
                setattr(self, name, attr)

    @property
    def x(self):
        return self.__foo.x

    def set_x(self, value):
        if isinstance(value, int) and value > 0:
            self.__foo.x = value

    mutate_x = set_x

if __name__ == '__main__':
    main()

Answer 2

简短的回答是：不，这不可能以合理的方式。

在这里，Python 的指导原则是使用style guide 中的措辞，即我们都是负责任的用户。这意味着代码被信任不会做愚蠢的事情，人们通常应该避免在没有充分理由的情况下与其他人的班级成员发生冲突。

防止人们意外更改值的第一个也是最好的方法是使用单个下划线 (_variable) 来标记它。但是，这可能无法为您提供防止意外修改变量的保护。

保护的下一步是使用双下划线。引用PEP-8:

为避免与子类发生名称冲突，请使用两个前导下划线来调用 Python 的名称修饰规则。

Python 将这些名称与类名混淆：如果类 Foo 具有名为 __a 的属性，则 Foo.__a 无法访问它。 （坚持使用的用户仍然可以通过调用 Foo._Foo__a 来获得访问权限。）通常，双前导下划线仅用于避免与设计为子类的类中的属性发生名称冲突。

重整使得意外覆盖值变得更加困难。

我强调了最后一句话，因为它很重要。使用这种机制来防止对成员的意外访问并不是很多成员都应该做的事情。

在您的具体情况下，我解决问题的方法是根本不进行子类化。考虑：

class Foo(object):
    def __init__(self, x):
        self.x = x

class Bar():
    def __init__(self, x):
        self._foo = Foo(x)

    @property
    def x(self):
        return self._foo.x

    def do_stuff(self, value):
        # Validate the value, and the wrapped object's state
        if valid:
            self._foo.x = value

当然这意味着Bar 必须包装您想要包装的所有Foo 方法。是的，仍然有人可以，

b = Bar(100)
b._foo.x = 127 # shame on them :)

或

b = Bar(100)
b._foo = EvilFoo(127)

但无意中更难做到。

Answer 3

您走在正确的轨道上，您希望将x 设为属性，而不是使其成为子类中的属性。您出错的地方是尝试将 x 的原始数据存储在 super.您想要做的是利用父类可以透明地使用子类的新属性并且不需要知道它现在是属性而不是属性的事实。像这样的东西应该适合你：

class Foo(object):
    def __init__(self, x):
        self.x = x

class Bar(Foo):

    _protected_x = None

    @property
    def x(self):
        return self._protected_x

    @x.setter
    def x(self, value):
        if self._protected_x is None:
            self._protected_x = value
        else:
            raise ValueError("Use set_x to change x.")

    def set_x(self, value):
        self._protected_x = value

b = Bar(12)
print b.x
b.set_x(5)
print b.x