在python 3.6及以上版本中，@override提供的功能可以使用python的描述符协议轻松实现，即set_name dunder方法:

class override:
    def __init__(self, func):
       self._func = func
       update_wrapper(self, func)

    def __get__(self, obj, obj_type):
        if obj is None:
            return self
        return self._func

    def __set_name__(self, obj_type, name):
        self.validate_override(obj_type, name)

    def validate_override(self, obj_type, name):
        for parent in obj_type.__bases__:
            func = parent.__dict__.get(name, None)
            if callable(func):
                return
        else:
            raise NotImplementedError(f"{obj_type.__name__} does not override {name}")

注意，这里的set_name是在定义包装类之后调用的，我们可以通过调用包装类的dunder方法基来获得它的父类。

对于它的父类，我们希望检查包装的函数是否在类中通过实现

检查函数名是否在类字典中 它是可调用的

使用i就像这样简单:

class AbstractShoppingCartService:
    def add_item(self, request: AddItemRequest) -> Cart:
        ...


class ShoppingCartService(AbstractShoppingCartService):
    @override
    def add_item(self, request: AddItemRequest) -> Cart:
        ...

Python不是Java。当然，没有真正的编译时检查。

我认为文档字符串中的注释就足够了。这允许您的方法的任何用户输入help(obj.method)，并看到该方法是一个覆盖。

你也可以用类Foo(interface)显式地扩展一个接口，这将允许用户输入help(interface .method)来了解你的方法想要提供的功能。

在Python 2.6+和Python 3.2+中，你可以这样做(实际上是模拟的，Python不支持函数重载，子类会自动覆盖父类的方法)。我们可以使用decorator。但首先，请注意Python的@decorators和Java的@Annotations是完全不同的东西。前一个是带有具体代码的包装器，后一个是编译器的标志。

为此，首先执行pip安装multipledispatch

from multipledispatch import dispatch as Override
# using alias 'Override' just to give you some feel :)

class A:
    def foo(self):
        print('foo in A')

    # More methods here


class B(A):
    @Override()
    def foo(self):
        print('foo in B')
    
    @Override(int)
    def foo(self,a):
        print('foo in B; arg =',a)
        
    @Override(str,float)
    def foo(self,a,b):
        print('foo in B; arg =',(a,b))
        
a=A()
b=B()
a.foo()
b.foo()
b.foo(4)
b.foo('Wheee',3.14)

输出:

foo in A
foo in B
foo in B; arg = 4
foo in B; arg = ('Wheee', 3.14)

注意，这里必须使用带有括号的decorator

需要记住的一件事是，由于Python没有直接的函数重载，所以即使类B没有继承自类A，但需要所有这些foo，也需要使用@Override(尽管在这种情况下使用别名'Overload'会更好看)

我创建的装饰器不仅检查覆盖属性的名称是否为该属性所在类的任何超类(无需指定超类)，还检查确保覆盖属性必须与被覆盖属性的类型相同。类方法被视为方法，静态方法被视为函数。这个装饰器适用于可调用对象、类方法、静态方法和属性。

源代码见:https://github.com/fireuser909/override

此装饰器仅适用于作为重写实例的类。OverridesMeta，但是如果你的类是一个自定义元类的实例，使用create_custom_overrides_meta函数来创建一个与覆盖装饰器兼容的元类。对于测试，运行覆盖。__init__模块。

就像其他人说的，不像Java，没有@Overide标签，但是上面你可以使用装饰器创建自己的，但是我建议使用getattrib()全局方法，而不是使用内部dict，这样你就会得到如下内容:

def Override(superClass):
    def method(func)
        getattr(superClass,method.__name__)
    return method

如果你想，你可以在你自己的try catch中捕获getattr()，但我认为getattr方法在这种情况下更好。

此外，它还捕获绑定到类的所有项，包括类方法和变量

即兴对@mkorpela的伟大回答，这里有一个版本

更精确的检查、命名和引发的Error对象

def overrides(interface_class):
    """
    Function override annotation.
    Corollary to @abc.abstractmethod where the override is not of an
    abstractmethod.
    Modified from answer https://stackoverflow.com/a/8313042/471376
    """
    def confirm_override(method):
        if method.__name__ not in dir(interface_class):
            raise NotImplementedError('function "%s" is an @override but that'
                                      ' function is not implemented in base'
                                      ' class %s'
                                      % (method.__name__,
                                         interface_class)
                                      )

        def func():
            pass

        attr = getattr(interface_class, method.__name__)
        if type(attr) is not type(func):
            raise NotImplementedError('function "%s" is an @override'
                                      ' but that is implemented as type %s'
                                      ' in base class %s, expected implemented'
                                      ' type %s'
                                      % (method.__name__,
                                         type(attr),
                                         interface_class,
                                         type(func))
                                      )
        return method
    return confirm_override

下面是它在实践中的样子:

NotImplementedError未在基类中实现

class A(object):
    # ERROR: `a` is not a implemented!
    pass

class B(A):
    @overrides(A)
    def a(self):
        pass

会导致更具有描述性的NotImplementedError错误

function "a" is an @override but that function is not implemented in base class <class '__main__.A'>

完整的堆栈

Traceback (most recent call last):
  …
  File "C:/Users/user1/project.py", line 135, in <module>
    class B(A):
  File "C:/Users/user1/project.py", line 136, in B
    @overrides(A)
  File "C:/Users/user1/project.py", line 110, in confirm_override
    interface_class)
NotImplementedError: function "a" is an @override but that function is not implemented in base class <class '__main__.A'>

NotImplementedError“期望实现的类型”

class A(object):
    # ERROR: `a` is not a function!
    a = ''

class B(A):
    @overrides(A)
    def a(self):
        pass

会导致更具有描述性的NotImplementedError错误

function "a" is an @override but that is implemented as type <class 'str'> in base class <class '__main__.A'>, expected implemented type <class 'function'>

完整的堆栈

Traceback (most recent call last):
  …
  File "C:/Users/user1/project.py", line 135, in <module>
    class B(A):
  File "C:/Users/user1/project.py", line 136, in B
    @overrides(A)
  File "C:/Users/user1/project.py", line 125, in confirm_override
    type(func))
NotImplementedError: function "a" is an @override but that is implemented as type <class 'str'> in base class <class '__main__.A'>, expected implemented type <class 'function'>

@mkorpela answer的伟大之处在于检查发生在初始化阶段。检查不需要“运行”。参考前面的例子，类B从未初始化(B())，但NotImplementedError仍然会引发。这意味着可以更快地捕获覆盖错误。