在Python中，我如何表明我重写了一个方法？

时间：2009-07-22 19:26:49

标签： python inheritance override self-documenting-code

例如，在Java中，@Override注释不仅提供了覆盖的编译时检查，而且还提供了出色的自我记录代码。

我只是在寻找文件（尽管如果它是一些像pylint这样的检查器的指示器，那就是奖金）。我可以在某处添加注释或docstring，但在Python中指示覆盖的惯用方法是什么？

11 个答案:

答案 0 :(得分：173)

更新（2015年5月23日）：基于此和fwc：s的回答，我创建了一个可安装的pip包[{3}}

我不时会在这里看到这个问题。 主要是在（再次）在我们的代码库中看到相同的错误之后发生：有人在“接口”中重命名方法时忘记了一些实现类的“接口”..

Python不是Java而是Python有权力 - 而且显性比隐含更好 - 并且在现实世界中存在真实的具体案例，这些事情对我有帮助。

所以这是一个覆盖装饰器的草图。这将检查作为参数给出的类是否与正在装饰的方法具有相同的方法（或其他）名称。

如果您能想到更好的解决方案，请在此发布！

def overrides(interface_class):
    def overrider(method):
        assert(method.__name__ in dir(interface_class))
        return method
    return overrider

它的工作原理如下：

class MySuperInterface(object):
    def my_method(self):
        print 'hello world!'


class ConcreteImplementer(MySuperInterface):
    @overrides(MySuperInterface)
    def my_method(self):
        print 'hello kitty!'

如果你做错了版本，它会在类加载期间引发一个断言错误：

class ConcreteFaultyImplementer(MySuperInterface):
    @overrides(MySuperInterface)
    def your_method(self):
        print 'bye bye!'

>> AssertionError!!!!!!!

答案 1 :(得分：25)

这是一个不需要指定interface_class名称的实现。

import inspect
import re

def overrides(method):
    # actually can't do this because a method is really just a function while inside a class def'n  
    #assert(inspect.ismethod(method))

    stack = inspect.stack()
    base_classes = re.search(r'class.+\((.+)\)\s*\:', stack[2][4][0]).group(1)

    # handle multiple inheritance
    base_classes = [s.strip() for s in base_classes.split(',')]
    if not base_classes:
        raise ValueError('overrides decorator: unable to determine base class') 

    # stack[0]=overrides, stack[1]=inside class def'n, stack[2]=outside class def'n
    derived_class_locals = stack[2][0].f_locals

    # replace each class name in base_classes with the actual class type
    for i, base_class in enumerate(base_classes):

        if '.' not in base_class:
            base_classes[i] = derived_class_locals[base_class]

        else:
            components = base_class.split('.')

            # obj is either a module or a class
            obj = derived_class_locals[components[0]]

            for c in components[1:]:
                assert(inspect.ismodule(obj) or inspect.isclass(obj))
                obj = getattr(obj, c)

            base_classes[i] = obj


    assert( any( hasattr(cls, method.__name__) for cls in base_classes ) )
    return method

答案 2 :(得分：10)

如果您只想将其用于文档目的，则可以定义自己的覆盖装饰器：

def override(f):
    return f


class MyClass (BaseClass):

    @override
    def method(self):
        pass

除非你以实际检查覆盖的方式创建覆盖（f），否则这实际上只是眼花缭乱。

但是，这是Python，为什么写它就像是Java？

答案 3 :(得分：7)

Python不是Java。当然没有像编译时检查那样的东西。

我认为文档字符串中的注释很多。这允许您的方法的任何用户键入help(obj.method)并查看该方法是一个覆盖。

您还可以使用class Foo(Interface)显式扩展界面，这样用户就可以输入help(Interface.method)来了解您的方法要提供的功能。

答案 4 :(得分：2)

像其他人说的那样，不像Java那样没有@Overide标签，但是你可以创建自己的装饰器，但是我建议使用getattrib（）全局方法而不是使用内部dict，这样就得到如下内容： / p> 

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

如果你想在自己的尝试中捕获getattr（），请抓住提高你自己的错误，但我认为在这种情况下getattr方法更好。

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

答案 5 :(得分：1)

在@mkorpela great answer上进行改进，这是带有

的版本

更精确的检查，命名和引发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答案的伟大之处在于检查发生在某些初始化阶段。该检查不需要“运行”。参考前面的示例，class B从未被初始化（B()），而NotImplementedError仍将升高。这意味着overrides错误会更快被发现。

答案 6 :(得分：1)

基于@mkorpela的出色回答，我编写了一个类似的软件包（ ipromise pypi github），该软件包可以进行更多检查：

假设A从B和C继承而B从C继承。ipromise检查该问题

  • 如果A.f覆盖B.f，则B.f必须存在，并且A必须继承自B。（这是覆盖包的检查）。

  • 您没有模式Af声明它覆盖Bf，然后它声明它覆盖Cf A应该说它从Cf覆盖，因为B可能决定停止覆盖此方法，因此不会导致在下游更新中。

  • 您没有模式A.f声明它覆盖C.f，但是B.f没有声明它的覆盖。

  • 您没有模式A.f声明它覆盖C.f，但是B.f声明它覆盖某些D.f。

它还具有用于标记和检查实现抽象方法的各种功能。

答案 7 :(得分：1)

在Python 2.6+和Python 3.2+中，您可以做到（实际上可以仿真，Python不支持函数重载，并且子类会自动覆盖父类的方法）。我们可以为此使用装饰器。但是首先，请注意，Python的tips = sns.load_dataset("tips") rows, cols = 1, 1 f, axs = plt.subplots( rows, cols) ax = plt.subplot( rows, cols, 1, facecolor=".9") for s in ax.spines: ax.spines[s].set_visible(False) sns.scatterplot(data=tips, x="total_bill", y="tip") 和Java的@decorators是完全不同的东西。前一个是带有具体代码的包装器，后一个是编译器的标志。

为此，请先执行@Annotations 

pip install 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)

请注意，您必须在此处使用带括号的装饰器

要记住的一件事是，由于Python没有直接的函数重载，因此，即使Class B不继承自Class A，但需要所有这些foo in A foo in B foo in B; arg = 4 foo in B; arg = ('Wheee', 3.14) ，您也需要使用@Override（尽管在这种情况下使用别名“过载”看起来会更好）

答案 8 :(得分：1)

您可以使用来自 PEP 544 的协议。使用这种方法，接口-实现关系只在使用站点声明。

假设你已经有了一个实现（我们称之为 MyFoobar），你定义了一个接口（一个协议），它具有你实现的所有方法和字段的签名，我们称之为 {{1} }.

然后，在使用站点，您将实现实例绑定声明为具有接口类型，例如IFoobar。现在，如果您使用界面中缺少的字段/方法，Mypy 将在使用站点抱怨（即使它可以在运行时工作！）。如果在实现中没有从接口实现一个方法，Mypy 也会报错。如果你实现了接口中不存在的东西，Mypy 不会抱怨。但这种情况很少见，因为接口定义紧凑且易于查看。您将无法实际使用该代码，因为 Mypy 会抱怨。

现在，这不会涵盖您在超类和实现类中都有实现的情况，例如 ABC 的某些用法。但是 myFoobar: IFoobar = MyFoobar() 在 Java 中甚至与 no implementation in the interface 一起使用。此解决方案涵盖了这种情况。

override

类型检查结果：

from typing import Protocol

class A(Protocol):
    def b(self):
        ...
    def d(self):  # we forgot to implement this in C
        ...

class C:
    def b(self):
        return 0

bob: A = C()

答案 9 :(得分：0)

听说最简单，在Jython下使用Java类工作：

class MyClass(SomeJavaClass):
     def __init__(self):
         setattr(self, "name_of_method_to_override", __method_override__)

     def __method_override__(self, some_args):
         some_thing_to_do()

答案 10 :(得分：0)

我所做的装饰器不仅检查了覆盖属性的名称是否是该属性所在类的任何超类，而无需指定超类，该装饰器还检查以确保覆盖属性必须为同一类型作为覆盖属性。类方法被视为方法，而静态方法被视为函数。此装饰器适用于可调用对象，类方法，静态方法和属性。

有关源代码，请参见：a good sample

此装饰器仅适用于作为override.OverridesMeta实例的类，但是如果您的类是自定义元类的实例，请使用create_custom_overrides_meta函数创建与覆盖装饰器兼容的元类。对于测试，请运行override .__ init__模块。

相关问题
最新问题