覆盖python中的属性

Question

所以，我试图找出最好的（用最少的代码最优雅）的方法来允许在 python 中覆盖属性的特定函数（例如，只是 getter、只是 setter 等）。我喜欢以下处理属性的方式，因为它们的所有方法都封装在同一个缩进的代码块中（更容易看出处理一个属性的函数在哪里停止以及处理下一个开始）：

@apply
def foo():
    """A foobar"""
    def fget(self):
        return self._foo
    def fset(self, val):
        self._foo = val
    return property(**locals())

但是，如果我想从一个以这种方式定义属性的类继承，然后，比如说，重写foo setter 函数，这似乎很棘手。我进行了一些搜索，发现的大多数答案都是在基类中定义单独的函数（例如getFoo 和setFoo），从它们显式创建属性定义（例如foo = property(lambda x: x.getFoo(), lambda x, y: x.setFoo(y), lambda x: x.delFoo())），然后根据需要覆盖getFoo、setFoo 和delFoo。

我不喜欢这个解决方案，因为这意味着我必须为每个属性定义lambas，然后写出每个函数调用（之前我本来可以完成property(**locals())）。我也没有得到我最初的封装。

理想情况下，我希望能够做的事情是这样的：

class A(object):
    def __init__(self):
        self.foo = 8
    @apply
    def foo():
        """A foobar"""
        def fget(self):
            return self._foo
        def fset(self, val):
            self._foo = val
        return property(**locals())

class ATimesTwo(A):
    @some_decorator
    def foo():
        def fset(self, val):
            self._foo = val * 2
        return something

然后输出看起来像：

>>> a = A()
>>> a.foo
8
>>> b = ATimesTwo()
>>> b.foo
16

基本上，ATimesTwo 继承自 A 的 getter 函数，但覆盖了 setter 函数。有谁知道这样做的方法（以类似于上面示例的方式）？ some_decorator 看起来像什么函数，foo 函数应该返回什么？

Answer 1

property 装饰器上的 Python docs 建议使用以下成语：

class C(object):
    def __init__(self):
        self._x = None
    @property
    def x(self):
        return self._x
    @x.setter
    def x(self, value):
        self._x = value
    @x.deleter
    def x(self):
        del self._x

然后子类可以像这样覆盖单个 setter/getter：

class C2(C):
    @C.x.getter
    def x(self):
        return self._x * -1

这有点棘手，因为覆盖多个方法似乎需要您执行以下操作：

class C3(C):
    @C.x.getter
    def x(self):
        return self._x * -1
    # C3 now has an x property with a modified getter
    # so modify its setter rather than C.x's setter.
    @x.setter 
    def x(self, value):
        self._x = value * 2

当然，当您覆盖 getter、setter 和 deleter 时，您可能只需重新定义 C3 的属性。

Answer 2

我相信你以前听说过这个，但自 Python 2.3 以来，apply 已被弃用 八年。不要使用它。您对locals() 的使用也违背了Python 的禅宗——显式优于隐式。如果你真的喜欢增加的缩进，没有必要创建一个一次性的对象，只需这样做

if True:
    @property
    def foo(self):
        return self._foo
    @foo.setter
    def foo(self, val):
        self._foo = val

这不会滥用locals，使用apply，需要创建额外的对象，或者需要在后面加上foo = foo() 使得更难看到块的结尾。它同样适用于您使用 property 的老式方式——只需照常使用 foo = property(fget, fset)。

如果要覆盖任意子类中的属性，可以使用recipe like this。

如果子类知道属性的定义位置，那么就这样做：

class ATimesTwo(A):
    @A.foo.setter
    def foo(self, val):
        self._foo = val * 2

Answer 3

stderr 的答案满足了大部分用例。

我想为您想要扩展getter、setter 和/或deleter 的情况添加一个解决方案。有两种方法：

1。子类property

第一种方法是继承内置的property 并添加作为getter、setter 和/或deleter 版本的装饰器，扩展当前获取、设置并删除回调

支持将方法附加到集合函数的属性示例：

class ExtendableProperty(property):
    def append_setter(self, fset):
        # Create a wrapper around the new fset that also calls the current fset
        _old_fset = self.fset

        def _appended_setter(obj, value):
            _old_fset(obj, value)
            fset(obj, value)
        # Use that wrapper as setter instead of only the new fset
        return self.setter(_appended_setter)

用法与普通属性相同，只是现在可以向属性设置器添加方法：

class A(object):
    @ExtendableProperty
    def prop(self):
        return self._prop

    @prop.setter
    def prop(self, v):
        self._prop = v


class B(A):
    @A.prop.append_setter
    def prop(self, v):
        print('Set', v)

>>> a = A()
>>> a.prop = 1
>>> a.prop
1

>>> b = B()
>>> b.prop = 1
Set 1
>>> b.prop
1

2。覆盖 getter、setter 和/或 deleter

使用普通属性，覆盖getter、setter或deleter，然后在父类的属性中添加对fget、fset或fdel的调用。

属性类型示例如示例 1：

class A(object):
    @property
    def prop(self):
        return self._prop

    @prop.setter
    def prop(self, v):
        self._prop = v


class B(A):
    @A.prop.setter
    def prop(self, v):
        A.prop.fset(self, v)  # This is the call to the original set method
        print('Set {}'.format(v))

我认为第一个选项看起来更好，因为不需要调用超级属性的 fset