在 Python 中，如何强制抽象方法在子 class 上是静态的？

Question

这是我想要的设置： A 应该是具有静态和抽象方法 f() 的抽象基 class。 B应该继承自A。要求： 1.你不应该能够实例化A 2.你不应该能够实例化B，除非它实现了一个静态的f()

从 this 问题中获得灵感，我尝试了几种方法。使用这些定义：

class abstractstatic(staticmethod):
    __slots__ = ()
    def __init__(self, function):
        super(abstractstatic, self).__init__(function)
        function.__isabstractmethod__ = True
    __isabstractmethod__ = True

class A:
    __metaclass__ = abc.ABCMeta
    @abstractstatic
    def f():
        pass

class B(A):
    def f(self):
        print 'f'

class A2:
    __metaclass__ = abc.ABCMeta
    @staticmethod
    @abc.abstractmethod
    def f():
        pass

class B2(A2):
    def f(self):
        print 'f'

此处 A2 和 B2 是使用通常的 Python 约定定义的，A 和 B 是使用 this 答案中建议的方式定义的。以下是我尝试过的一些操作以及不想要的结果。

与 classes A/B:

>>> B().f()
f
#This should have thrown, since B doesn't implement a static f()

与 classes A2/B2:

>>> A2()
<__main__.A2 object at 0x105beea90>
#This should have thrown since A2 should be an uninstantiable abstract class

>>> B2().f()
f
#This should have thrown, since B2 doesn't implement a static f()

由于这两种方法都无法提供我想要的输出，我该如何实现我想要的？

Answer 1

你不能只用 ABCMeta 做你想做的事。 ABC 强制执行不执行任何类型检查，仅强制执行具有正确名称的属性的存在。

举个例子：

>>> from abc import ABCMeta, abstractmethod, abstractproperty
>>> class Abstract(object):
...     __metaclass__ = ABCMeta
...     @abstractmethod
...     def foo(self): pass
...     @abstractproperty
...     def bar(self): pass
... 
>>> class Concrete(Abstract):
...     foo = 'bar'
...     bar = 'baz'
... 
>>> Concrete()
<__main__.Concrete object at 0x104b4df90>

即使 foo 和 bar 都是简单的属性，我也能够构建 Concrete()。

ABCMeta metaclass 仅跟踪在 __isabstractmethod__ 属性为真时还剩下多少对象；当从 metaclass（调用 ABCMeta.__new__）创建 class 时，cls.__abstractmethods__ 属性然后被设置为一个 frozenset 对象，所有名称仍然是摘要.

type.__new__ 然后测试 frozenset 并在您尝试创建实例时抛出 TypeError。

您必须在此处生成您的 自己的 __new__ 方法； subclass ABCMeta 并在新的 __new__ 方法中添加类型检查。该方法应该在基础 classes 上查找 __abstractmethods__ 集，在 MRO 中找到具有 __isabstractmethod__ 属性的相应对象，然后对当前 class 属性进行类型检查。

这意味着您将在定义 class 时抛出异常，而不是实例。为此，您需要向 ABCMeta subclass 添加一个 __call__ 方法，并根据您自己的 __new__ 方法收集的有关类型的信息抛出异常错了；与 ABCMeta 和 type.__new__ 目前所做的类似的两阶段过程。或者，更新 class 上的 __abstractmethods__ 集以添加任何已实现但类型错误的名称，并将其留给 type.__new__ 以抛出异常。

下面的实现采用了最后的策略；如果实现的类型不匹配（使用映射），将名称添加回 __abstractmethods__：

from types import FunctionType

class ABCMetaTypeCheck(ABCMeta):
    _typemap = {  # map abstract type to expected implementation type
        abstractproperty: property,
        abstractstatic: staticmethod,
        # abstractmethods return function objects
        FunctionType: FunctionType,
    }
    def __new__(mcls, name, bases, namespace):
        cls = super(ABCMetaTypeCheck, mcls).__new__(mcls, name, bases, namespace)
        wrong_type = set()
        seen = set()
        abstractmethods = cls.__abstractmethods__
        for base in bases:
            for name in getattr(base, "__abstractmethods__", set()):
                if name in seen or name in abstractmethods:
                    continue  # still abstract or later overridden
                value = base.__dict__.get(name)  # bypass descriptors
                if getattr(value, "__isabstractmethod__", False):
                    seen.add(name)
                    expected = mcls._typemap[type(value)]
                    if not isinstance(namespace[name], expected):
                        wrong_type.add(name)
        if wrong_type:
            cls.__abstractmethods__ = abstractmethods | frozenset(wrong_type)
        return cls

使用此元class，您将获得预期的输出：

>>> class Abstract(object):
...     __metaclass__ = ABCMetaTypeCheck
...     @abstractmethod
...     def foo(self): pass
...     @abstractproperty
...     def bar(self): pass
...     @abstractstatic
...     def baz(): pass
... 
>>> class ConcreteWrong(Abstract):
...     foo = 'bar'
...     bar = 'baz'
...     baz = 'spam'
... 
>>> ConcreteWrong()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class ConcreteWrong with abstract methods bar, baz, foo
>>> 
>>> class ConcreteCorrect(Abstract):
...     def foo(self): return 'bar'
...     @property
...     def bar(self): return 'baz'
...     @staticmethod
...     def baz(): return  'spam'
... 
>>> ConcreteCorrect()
<__main__.ConcreteCorrect object at 0x104ce1d10>

在 Python 中，如何强制抽象方法在子 class 上是静态的？

In Python, how to enforce an abstract method to be static on the child class?

python

abstract-class

static-methods

abc