抽象属性（不是属性）？

Question

定义抽象实例属性而不是属性的最佳实践是什么？

我想写这样的东西：

class AbstractFoo(metaclass=ABCMeta):

    @property
    @abstractmethod
    def bar(self):
        pass

class Foo(AbstractFoo):

    def __init__(self):
        self.bar = 3

代替：

class Foo(AbstractFoo):

    def __init__(self):
        self._bar = 3

    @property
    def bar(self):
        return self._bar

    @bar.setter
    def setbar(self, bar):
        self._bar = bar

    @bar.deleter
    def delbar(self):
        del self._bar

属性很方便，但对于不需要计算的简单属性，它们是多余的。这对于将由用户子类化和实现的抽象类尤其重要（我不想强迫某人使用@property，因为他本来可以在__init__ 中写self.foo = foo）。

Abstract attributes in Python 问题建议作为使用@property 和@abstractmethod 的唯一答案：它没有回答我的问题。

通过AbstractAttribute 的抽象类属性的ActiveState 配方可能是正确的方法，但我不确定。它也只适用于类属性而不是实例属性。

Answer 1

与公认的答案相比，一个可能更好的解决方案：

from better_abc import ABCMeta, abstract_attribute    # see below

class AbstractFoo(metaclass=ABCMeta):

    @abstract_attribute
    def bar(self):
        pass

class Foo(AbstractFoo):
    def __init__(self):
        self.bar = 3

class BadFoo(AbstractFoo):
    def __init__(self):
        pass

它的行为如下：

Foo()     # ok
BadFoo()  # will raise: NotImplementedError: Can't instantiate abstract class BadFoo
# with abstract attributes: bar

此答案使用与接受的答案相同的方法，但与内置 ABC 很好地集成，并且不需要 check_bar() 助手的样板。

这是better_abc.py的内容：

from abc import ABCMeta as NativeABCMeta

class DummyAttribute:
    pass

def abstract_attribute(obj=None):
    if obj is None:
        obj = DummyAttribute()
    obj.__is_abstract_attribute__ = True
    return obj


class ABCMeta(NativeABCMeta):

    def __call__(cls, *args, **kwargs):
        instance = NativeABCMeta.__call__(cls, *args, **kwargs)
        abstract_attributes = {
            name
            for name in dir(instance)
            if getattr(getattr(instance, name), '__is_abstract_attribute__', False)
        }
        if abstract_attributes:
            raise NotImplementedError(
                "Can't instantiate abstract class {} with"
                " abstract attributes: {}".format(
                    cls.__name__,
                    ', '.join(abstract_attributes)
                )
            )
        return instance

好消息是你可以做到：

class AbstractFoo(metaclass=ABCMeta):
    bar = abstract_attribute()

它的工作原理和上面一样。

也可以使用：

class ABC(ABCMeta):
    pass

定义自定义 ABC 助手。 PS。我认为这段代码是 CC0。

这可以通过使用 AST 解析器通过扫描__init__ 代码来提高（在类声明时），但现在看来有点矫枉过正（除非有人愿意实现）。

2021：打字支持

你可以使用：

from typing import cast, Any, Callable, TypeVar


R = TypeVar('R')


def abstract_attribute(obj: Callable[[Any], R] = None) -> R:
    _obj = cast(Any, obj)
    if obj is None:
        _obj = DummyAttribute()
    _obj.__is_abstract_attribute__ = True
    return cast(R, _obj)

这将使 mypy 突出显示一些打字问题

class AbstractFooTyped(metaclass=ABCMeta):

    @abstract_attribute
    def bar(self) -> int:
        pass


class FooTyped(AbstractFooTyped):
    def __init__(self):
        # skipping assignment (which is required!) to demonstrate
        # that it works independent of when the assignment is made
        pass


f_typed = FooTyped()
_ = f_typed.bar + 'test'   # Mypy: Unsupported operand types for + ("int" and "str")


FooTyped.bar = 'test'    # Mypy: Incompatible types in assignment (expression has type "str", variable has type "int")
FooTyped.bar + 'test'    # Mypy: Unsupported operand types for + ("int" and "str")

对于速记符号，正如@SMiller 在 cmets 中所建议的那样：

class AbstractFooTypedShorthand(metaclass=ABCMeta):
    bar: int = abstract_attribute()


AbstractFooTypedShorthand.bar += 'test'   # Mypy: Unsupported operand types for + ("int" and "str")

Answer 2

如果你真的想强制一个子类定义一个给定的属性，你可以使用元类：

 class AbstractFooMeta(type):
 
     def __call__(cls, *args, **kwargs):
         """Called when you call Foo(*args, **kwargs) """
         obj = type.__call__(cls, *args, **kwargs)
         obj.check_bar()
         return obj
     
     
 class AbstractFoo(object):
     __metaclass__ = AbstractFooMeta
     bar = None
 
     def check_bar(self):
         if self.bar is None:
             raise NotImplementedError('Subclasses must define bar')
 
 
 class GoodFoo(AbstractFoo):
     def __init__(self):
         self.bar = 3
 
 
 class BadFoo(AbstractFoo):
     def __init__(self):
         pass

基本上，元类重新定义 __call__ 以确保在实例的 init 之后调用 check_bar。

GoodFoo()  # ok
BadFoo ()  # yield NotImplementedError

Answer 3

仅仅因为您在抽象基类上将其定义为abstractproperty 并不意味着您必须在子类上创建一个属性。

例如你可以：

In [1]: from abc import ABCMeta, abstractproperty

In [2]: class X(metaclass=ABCMeta):
   ...:     @abstractproperty
   ...:     def required(self):
   ...:         raise NotImplementedError
   ...:

In [3]: class Y(X):
   ...:     required = True
   ...:

In [4]: Y()
Out[4]: <__main__.Y at 0x10ae0d390>

如果你想初始化__init__中的值，你可以这样做：

In [5]: class Z(X):
   ...:     required = None
   ...:     def __init__(self, value):
   ...:         self.required = value
   ...:

In [6]: Z(value=3)
Out[6]: <__main__.Z at 0x10ae15a20>

由于 Python 3.3 abstractproperty 是 deprecated。所以 Python 3 用户应该使用以下代码：

from abc import ABCMeta, abstractmethod

class X(metaclass=ABCMeta):
    @property
    @abstractmethod
    def required(self):
        raise NotImplementedError

Answer 4

问题不在于什么，而在于何时：

from abc import ABCMeta, abstractmethod

class AbstractFoo(metaclass=ABCMeta):
    @abstractmethod
    def bar():
        pass

class Foo(AbstractFoo):
    bar = object()

isinstance(Foo(), AbstractFoo)
#>>> True

bar 不是方法没关系！问题是检查的方法__subclasshook__是一个classmethod，所以只关心是否是class，而不关心instance，有属性。

---

我建议你不要强求，因为这是一个难题。另一种方法是强制他们预定义属性，但这只会留下虚拟属性，只会使错误静音。

Answer 5

正如Anentropic 所说，您不必将abstractproperty 实现为另一个property。

但是，所有答案似乎都忽略了一件事情是 Python 的成员槽（__slots__ 类属性）。需要实现抽象属性的 ABC 用户只需在 __slots__ 中定义它们，前提是只需要一个数据属性。

所以有类似的，

class AbstractFoo(abc.ABC):
    __slots__ = ()

    bar = abc.abstractproperty()

用户可以简单地定义子类，

class Foo(AbstractFoo):
    __slots__ = 'bar',  # the only requirement

    # define Foo as desired

    def __init__(self):
        self.bar = ...

这里，Foo.bar 的行为类似于常规实例属性，只是实现方式不同。这简单、高效，并且避免了您描述的 @property 样板。

无论 ABC 是否在其类的主体中定义 __slots__，这都有效。但是，一直使用__slots__ 不仅可以节省内存并提供更快的属性访问，还可以提供有意义的描述符，而不是在子类中使用中间体（例如bar = None 或类似的）。¹

一些答案​​建议进行“抽象”属性检查之后 实例化（即在元类__call__() 方法），但我发现这不仅浪费而且作为初始化步骤可能效率低下可能会很耗时。

简而言之，ABC 的子类需要的是覆盖相关的描述符（无论是属性还是方法），不管如何，并向您的用户记录可以使用 __slots__在我看来，抽象属性的实现是更合适的方法。

---

¹_{无论如何，至少，ABC 应该总是定义一个空的__slots__ 类属性，否则子类将被强制拥有__dict__（动态属性访问）和__weakref__（弱引用支持）在实例化时。请参阅abc 或collections.abc 模块以了解标准库中的示例。}

Answer 6

我已经搜索了一段时间，但没有看到任何我喜欢的东西。你可能知道，如果你这样做：

class AbstractFoo(object):
    @property
    def bar(self):
        raise NotImplementedError(
                "Subclasses of AbstractFoo must set an instance attribute "
                "self._bar in it's __init__ method")

class Foo(AbstractFoo):
    def __init__(self):
        self.bar = "bar"

f = Foo()

你会得到一个AttributeError: can't set attribute，这很烦人。

要解决这个问题，您可以这样做：

class AbstractFoo(object):

    @property
    def bar(self):
        try:
            return self._bar
        except AttributeError:
            raise NotImplementedError(
                "Subclasses of AbstractFoo must set an instance attribute "
                "self._bar in it's __init__ method")

class OkFoo(AbstractFoo):
    def __init__(self):
        self._bar = 3

class BadFoo(AbstractFoo):
    pass

a = OkFoo()
b = BadFoo()
print a.bar
print b.bar  # raises a NotImplementedError

这避免了AttributeError: can't set attribute，但如果你只是把抽象属性放在一起：

class AbstractFoo(object):
    pass

class Foo(AbstractFoo):
    pass

f = Foo()
f.bar

你会得到一个AttributeError: 'Foo' object has no attribute 'bar'，它可以说几乎和 NotImplementedError 一样好。所以真的我的解决方案只是从另一个交易一个错误消息..你必须在 init 中使用 self._bar 而不是 self.bar。

Answer 7

在https://docs.python.org/2/library/abc.html 之后，您可以在 Python 2.7 中执行类似的操作：

from abc import ABCMeta, abstractproperty


class Test(object):
    __metaclass__ = ABCMeta

    @abstractproperty
    def test(self): yield None

    def get_test(self):
        return self.test


class TestChild(Test):

    test = None

    def __init__(self, var):
        self.test = var


a = TestChild('test')
print(a.get_test())