No Python, como indico que estou substituindo um método?

Em Java, por exemplo, a @Overrideanotação não apenas fornece a verificação em tempo de compilação de uma substituição, mas também oferece um excelente código de auto-documentação.

Estou apenas procurando por documentação (embora seja um indicador para algum verificador como o pylint, isso é um bônus). Posso adicionar um comentário ou uma documentação em algum lugar, mas qual é a maneira idiomática de indicar uma substituição no Python?

Com base nisso e na resposta do fwc: s, criei um pacote instalável pip https://github.com/mkorpela/overrides

De tempos em tempos, acabo aqui olhando para essa pergunta. Principalmente isso ocorre depois (novamente) da mesma falha em nossa base de código: alguém esqueceu uma classe de implementação de "interface" enquanto renomeia um método na "interface".

Bem, o Python não é Java, mas o Python tem poder - e explícito é melhor do que implícito - e há casos concretos reais no mundo real em que isso poderia me ajudar.

Então, aqui está um esboço do decorador de substituições. Isso verificará se a classe fornecida como parâmetro tem o mesmo nome de método (ou algo assim) que o método que está sendo decorado.

Se você pode pensar em uma solução melhor, por favor poste aqui!

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

Funciona da seguinte maneira:

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


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

e se você fizer uma versão defeituosa, ocorrerá um erro de asserção durante o carregamento da classe:

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

>> AssertionError!!!!!!!

Aqui está uma implementação que não requer especificação do nome 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

Se você desejar isso apenas para fins de documentação, poderá definir seu próprio decorador de substituição:

def override(f):
    return f


class MyClass (BaseClass):

    @override
    def method(self):
        pass

Na verdade, isso não passa de um colírio para os olhos, a menos que você crie a substituição (f) de uma maneira que realmente verifique a substituição.

Mas então, este é Python, por que escrevê-lo como se fosse Java?

Python não é Java. Obviamente, não existe algo como verificação em tempo de compilação.

Eu acho que um comentário na doutrina é suficiente. Isso permite que qualquer usuário do seu método digite help(obj.method)e veja que o método é uma substituição.

Você também pode estender explicitamente uma interface com class Foo(Interface), o que permitirá aos usuários digitar help(Interface.method)para ter uma idéia da funcionalidade que seu método se destina a fornecer.

Improvisando a ótima resposta do @mkorpela , aqui está uma versão com

verificações, nomes e objetos de erro mais precisos

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

Aqui está o que parece na prática:

NotImplementedError" não implementado na classe base "

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

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

resulta em NotImplementedErrorerro mais descritivo

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

pilha completa

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" tipo implementado esperado "

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

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

resulta em NotImplementedErrorerro mais descritivo

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

pilha completa

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'>

A grande coisa sobre a resposta @mkorpela é que a verificação acontece durante alguma fase de inicialização. A verificação não precisa ser "executada". Referindo-se aos exemplos anteriores, class Bnunca é inicializado ( B()), ainda NotImplementedErrorassim o valor aumentará. Isso significa que os overrideserros são detectados antes.

Como outros já disseram, diferentemente do Java, não existe a tag @Overide, mas acima você pode criar seus próprios decoradores. No entanto, sugiro usar o método global getattrib () em vez de usar o dict interno para obter algo como o seguinte:

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

Se você quiser, você pode pegar o getattr () em sua própria tentativa, tente aumentar o seu próprio erro, mas acho que o método getattr é melhor nesse caso.

Isso também captura todos os itens vinculados a uma classe, incluindo métodos de classe e variáveis

Baseado na ótima resposta do @ mkorpela, escrevi um pacote semelhante ( ipromise pypi github ) que faz muito mais verificações:

Suponha que Aherda Be C, Bherda C.

O módulo ipromise verifica se:

• Se A.fsubstitui B.f, B.fdeve existir e Adeve herdar de B. (Esta é a verificação do pacote de substituições).

• Você não tem o padrão A.fque declara que substitui B.f, que declara que substitui C.f. Adeve dizer que substitui a partir de C.fpois Bpode decidir parar de substituir esse método e isso não deve resultar em atualizações posteriores.

• Você não tem o padrão A.fdeclara que ele substitui C.f, mas B.fnão declara sua substituição.

• Você não tem o padrão A.fque declara que substitui C.f, mas B.fdeclara que substitui de algumas D.f.

Ele também possui vários recursos para marcar e verificar a implementação de um método abstrato.

O Hear é mais simples e funciona sob o Jython com classes 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()

O decorador que fiz não apenas verificou se o nome do atributo de substituição é qualquer superclasse da classe em que o atributo está sem precisar especificar uma superclasse, mas também decorou também para garantir que o atributo de substituição seja do mesmo tipo que o de substituição atributo. Os métodos de classe são tratados como métodos e os métodos estáticos são tratados como funções. Este decorador trabalha para chamadas, métodos de classe, métodos estáticos e propriedades.

Para obter o código-fonte, consulte: https://github.com/fireuser909/override

Esse decorador funciona apenas para classes que são instâncias de substituição.OverridesMeta, mas se sua classe for uma instância de uma metaclasse personalizada, use a função create_custom_overrides_meta para criar uma metaclasse compatível com o decorador de substituição. Para testes, execute o módulo override .__ init__.

No Python 2.6+ e no Python 3.2+ você pode fazê-lo (na verdade, simule , o Python não suporta sobrecarga de funções e a classe filho substitui automaticamente o método dos pais). Podemos usar decoradores para isso. Mas primeiro, observe que Python @decoratorse Java @Annotationssão coisas totalmente diferentes. O anterior é um invólucro com código concreto, enquanto mais tarde é um sinalizador para o compilador.

Para isso, primeiro faça 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)

resultado:

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

Observe que você deve usar o decorador aqui entre parênteses

Uma coisa a lembrar é que, como o Python não possui sobrecarga de função diretamente, mesmo que a Classe B não herda da Classe A, mas precise de todos esses foos, você também precisará usar o @Override (embora o apelido 'Overload' seja parecido) melhor nesse caso)