Python 仅使用装饰器覆盖抽象方法属性设置器和获取器

Question

I'm trying to create an abstract class that would force the implementation to implement both a getter and a setter. I'm following what is described at https://docs.python.org/3.4/library/abc.html#abc.abstractproperty but I keep getting

Traceback (most recent call last):
  File "test.py", line 30, in <module>
    test = B('bar')
TypeError: Can't instantiate abstract class B with abstract methods foo

even though I implement both foo getter and setter in B.

Here is my code:

from abc import ABC, abstractmethod

class A(ABC):
    @property
    @abstractmethod
    def foo(self):
        pass

    @foo.setter
    @abstractmethod
    def foo(self, val):
        pass

    def do_stuff(self):
        print(self.foo)

class B(A):
    def __init__(self, val):
        self._foo = val

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

    @A.foo.setter
    def foo(self, val):
        self._foo = val

if __name__ == '__main__':
    test = B('bar')
    test.do_stuff()
    test.foo = 'barr'
    test.do_stuff()

I know there is a way to do this by defining the property without using the decorator, like so

from abc import ABC, abstractmethod

class A(ABC):
    @abstractmethod
    def _get_foo(self):
        pass

    @abstractmethod
    def _set_foo(self, val):
        pass

    def do_stuff(self):
        print(self.foo)

    foo = property(_get_foo, _set_foo)

class B(A):
    def __init__(self, val):
        self._foo = val

    def _get_foo(self):
        return self._foo

    def _set_foo(self, val):
        self._foo = val

    foo = property(_get_foo, _set_foo)

if __name__ == '__main__':
    test = B('bar')
    test.do_stuff()
    test.foo = 'barr'
    test.do_stuff()

While this does work, there surely must be a way to do that with just the decorators, no?

I'm running python 3.4.

Answer 1

Your code raises an exception because you're using the A.foo.setter decorator on the B.foo method, so the B.foo method does not actually implement the abstract method A.foo with the same signature.

Remove the A. specification from the decorator, and your code would work:

@foo.setter
def foo(self, val):
    self._foo = val

With the fix, you'll find that the class A does enforce that the child classes implement both the getter and the setter for foo (the exception you saw was actually a result of you not implementing the setter).

Answer 2

According to this issue you would need to go over an additional class in the hierarchy that implements solely the getter. The setter would then stay with the concrete class:

from abc import ABC, abstractmethod

class A(ABC):

    @property
    @abstractmethod
    def foo(self):
        pass

    @foo.setter
    @abstractmethod
    def foo(self, val):
        pass

    def do_stuff(self):
        print(self.foo)

class B(A):

    _foo = None

    @A.foo.getter
    def foo(self):
        return self._foo

class C(B):

    def __init__(self, val):
        self._foo = val

    @B.foo.setter
    def foo(self, val):
        self._foo = val

if __name__ == '__main__':
    test = C('bar')
    test.do_stuff()
    test.foo = 'barr'
    test.do_stuff()

If you remove either the getter in B or the setter in C you will get the desired TypeError exception.

This solution, however, forces you to put the definitions of getter and setter in two different classes, which might be impractical in real applications.