Python 中的抽象属性

Question

在 Python 中使用抽象属性实现以下 Scala 代码的最短/最优雅的方法是什么？

abstract class Controller {

    val path: String

}

Scala 编译器强制 Controller 的子类定义“路径”。子类看起来像这样：

class MyController extends Controller {

    override val path = "/home"

}

Answer 1

Python 3.3+

from abc import ABCMeta, abstractmethod


class A(metaclass=ABCMeta):
    def __init__(self):
        # ...
        pass

    @property
    @abstractmethod
    def a(self):
        pass

    @abstractmethod
    def b(self):
        pass


class B(A):
    a = 1

    def b(self):
        pass

未能在派生类 B 中声明 a 或 b 将引发 TypeError，例如：

TypeError：无法使用抽象方法a实例化抽象类B

Python 2.7

有一个 @abstractproperty 装饰器：

from abc import ABCMeta, abstractmethod, abstractproperty


class A:
    __metaclass__ = ABCMeta

    def __init__(self):
        # ...
        pass

    @abstractproperty
    def a(self):
        pass

    @abstractmethod
    def b(self):
        pass


class B(A):
    a = 1

    def b(self):
        pass

Answer 2

自从这个问题最初被提出以来，python 改变了抽象类的实现方式。我在 python 3.6 中使用了 abc.ABC 形式主义，使用了稍微不同的方法。这里我将常量定义为必须在每个子类中定义的属性。

from abc import ABC, abstractmethod


class Base(ABC):

    @classmethod
    @property
    @abstractmethod
    def CONSTANT(cls):
        raise NotImplementedError

    def print_constant(self):
        print(type(self).CONSTANT)


class Derived(Base):
    CONSTANT = 42

这会强制派生类定义常量，否则当您尝试实例化子类时将引发 TypeError 异常。当您想要将常量用于抽象类中实现的任何功能时，必须通过 type(self).CONSTANT 访问子类常量，而不仅仅是 CONSTANT，因为值在基类中未定义。

还有其他方法可以实现此目的，但我喜欢这种语法，因为在我看来，它对读者来说是最简单明了的。

前面的答案都触及了有用的要点，但我觉得接受的答案并没有直接回答问题，因为

• 问题要求在抽象类中实现，但接受的答案不遵循抽象形式主义。
• 问题要求强制实施。我认为这个答案中的执行更加严格，因为如果未定义 CONSTANT，则在实例化子类时会导致运行时错误。接受的答案允许实例化对象，并且仅在访问 CONSTANT 时抛出错误，从而使执行不那么严格。

这并不是要指责原来的答案。自发布以来，抽象类语法发生了重大变化，在本例中允许更简洁、更实用的实现。

Answer 3

Python 为此有一个内置异常，尽管直到运行时您才会遇到该异常。

class Base(object):
    @property
    def path(self):
        raise NotImplementedError


class SubClass(Base):
    path = 'blah'

Answer 4

在 Python 3.6+ 中，您可以注释抽象类的属性（或任何变量）而不提供该属性的值。

from abc import ABC

class Controller(ABC):
    path: str

class MyController(Controller):
    def __init__(self, path: str):
        self.path = path

这使得代码非常干净，很明显该属性是抽象的。

应该注意的是，如果子类不提供实现，则不会在定义时引发异常。但是，如果任何东西尝试访问未定义的属性，则会引发 AttributeError 异常。

Answer 5

您可以在 abc.ABC 抽象基类中创建一个属性其值例如 NotImplemented 这样，如果该属性未被覆盖然后使用，则会在运行时显示一个明确的错误，表明其意图。

以下代码使用 PEP 484 类型提示来帮助 PyCharm 正确地静态分析path 属性的类型。

from abc import ABC

class Controller(ABC):
    path: str = NotImplemented

class MyController(Controller):
    path = "/home"

Answer 6

从 Python 3.6 开始，您可以使用 __init_subclass__ 在初始化时检查子类的类变量：

from abc import ABC

class A(ABC):
    @classmethod
    def __init_subclass__(cls):
        required_class_variables = [
            'foo',
            'bar',
        ]
        for var in required_class_variables:
            if not hasattr(cls, var):
                raise NotImplementedError(
                    f'Class {cls} lacks required `{var}` class attribute'
                )

如果未定义缺少的类变量，这会在子类初始化时引发错误，因此您不必等到访问缺失的类变量。

Answer 7

对于 Python 3.3+ 有一个优雅的解决方案

from abc import ABC, abstractmethod
    
class BaseController(ABC):
    @property
    @abstractmethod
    def path(self) -> str:
        ...

class Controller(BaseController):
    path = "/home"


# Instead of an elipsis, you can add a docstring for clarity
class AnotherBaseController(ABC):
    @property
    @abstractmethod
    def path(self) -> str:
        """
        :return: the url path of this controller
        """

尽管已经给出了一些很好的答案，但我认为这个答案仍然会增加一些价值。这种方法有两个优点：

1. 抽象方法体中的

   ... 比 pass 更可取。与 pass 不同，... 意味着无操作，其中 pass 仅表示缺少实际实现

2. 比抛出 NotImplementedError(...) 更推荐使用...。如果子类中缺少抽象字段的实现，这会自动提示极其详细的错误。相反，NotImplementedError 本身并没有说明为什么缺少实现。而且，实际饲养它还需要体力劳动。

Answer 8

我修改了一点 @James 答案，这样所有这些装饰器就不会占据太多位置。如果您有多个这样的抽象属性要定义，这很方便：

from abc import ABC, abstractmethod

def abstractproperty(func):
   return property(classmethod(abstractmethod(func)))

class Base(ABC):

    @abstractproperty
    def CONSTANT(cls): ...

    def print_constant(self):
        print(type(self).CONSTANT)


class Derived(Base):
    CONSTANT = 42

class BadDerived(Base):
    BAD_CONSTANT = 42

Derived()       # -> Fine
BadDerived()    # -> Error

Answer 9

Python3.6 的实现可能如下所示：

In [20]: class X:
    ...:     def __init_subclass__(cls):
    ...:         if not hasattr(cls, 'required'):
    ...:             raise NotImplementedError

In [21]: class Y(X):
    ...:     required = 5
    ...:     

In [22]: Y()
Out[22]: <__main__.Y at 0x7f08408c9a20>

Answer 10

您的基类可以实现一个 __new__ 方法来检查类属性：

class Controller(object):
    def __new__(cls, *args, **kargs):
        if not hasattr(cls,'path'): 
            raise NotImplementedError("'Controller' subclasses should have a 'path' attribute")
        return object.__new__(cls)

class C1(Controller):
    path = 42

class C2(Controller):
    pass


c1 = C1() 
# ok

c2 = C2()  
# NotImplementedError: 'Controller' subclasses should have a 'path' attribute

这样在实例化时会引发错误

Answer 11

class AbstractStuff:
    @property
    @abc.abstractmethod
    def some_property(self):
        pass

我认为从 3.3 开始，abc.abstractproperty 已被弃用。

Answer 12

Bastien Léonard 的答案提到了抽象基类模块，而 Brendan Abel 的答案则涉及引发错误的未实现属性。为了确保该类不会在模块外部实现，您可以在基本名称前加上下划线，表示它是模块私有的（即不导入）。

IE

class _Controller(object):
    path = '' # There are better ways to declare attributes - see other answers

class MyController(_Controller):
    path = '/Home'

Answer 13

看一下 abc（抽象基类）模块： http://docs.python.org /library/abc.html

但是，在我看来，最简单和最常见的解决方案是在创建基类的实例或访问其属性时引发异常。