En Python, ¿cómo señalo que estoy anulando un método?

Question

En Java, por ejemplo, la anotación @Override no solo proporciona la verificación en tiempo de compilación de una anulación sino que proporciona un excelente código de auto-documentación. Solo estoy buscando documentación (aunque si es un indicador para algún inspector como la pildora, eso es una ventaja). Puedo agregar un comentario o un docstring en alguna parte, pero ¿cuál es la manera idiomática de indicar una anulación en Python?

Answer 1

ACTUALIZACIÓN (05/23/2015): Basado en esto y fwc: s respuesta que creó un pip paquete instalable https://github.com/mkorpela/overrides

De vez en cuando llegué aquí mirando a esta pregunta. Principalmente esto sucede después de (otra vez) ver el mismo error en nuestra base de código: Alguien ha olvidado alguna clase de implementación de "interfaz" al cambiar el nombre de un método en la "interfaz".

Bueno Python no es Java pero Python tiene el poder -y explícito es mejor que implícito- y hay casos reales reales en el mundo real donde esto me habría ayudado.

Así que aquí hay un boceto del decodificador de anulaciones. Esto verificará que la clase dada como parámetro tenga el mismo nombre de método (o algo) que el método que se está decorando.

Si puede pensar en una solución mejor, ¡por favor publíquela aquí!

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

funciona de la siguiente manera:

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


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

y si lo hace una versión defectuosa se generará un error afirmación durante la carga de clases:

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

>> AssertionError!!!!!!! 

Answer 2

Hasta donde yo sé, no hay una forma especial de indicar una anulación en Python. Simplemente defina el método e incluya una docstring, como siempre.

Answer 3

Python no es Java. Por supuesto, no existe tal cosa como la verificación en tiempo de compilación.

Creo que un comentario en el docstring es suficiente. Esto permite a cualquier usuario de su método escribir help(obj.method) y ver que el método sea una anulación.

También puede extender explícitamente una interfaz con class Foo(Interface), que permitirá a los usuarios escribir help(Interface.method) para tener una idea acerca de la funcionalidad que su método está destinado a proporcionar.

Answer 4

Si desea que esta para fines de documentación única, puede definir su propia anulación decorador:

def override(f): 
    return f 


class MyClass (BaseClass): 

    @override 
    def method(self): 
     pass 

Esto es realmente nada más que los ojos dulces, a no ser que se crea anulación (f) de tal manera que es en realidad comprueba si hay una anulación.

Pero entonces, esto es Python, ¿por qué escribirlo como si fuera Java?

Answer 5

Aquí es una implementación que no lo hace requieren especificación del nombre de la clase de interfaz.

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 

Answer 6

Como otros han dicho a diferencia de Java no hay etiqueta @Overide sin embargo por encima de usted puede crear sus propios utilizando decoradores sin embargo se recomienda usar el getattrib() método global en lugar de utilizar el dict interna para que pueda obtener algo así como lo siguiente:

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

Si quería se podía tomar getattr() en su propio intento de captura elevar su propio error, pero creo que el método getattr es mejor en este caso.

También este atrapa todos los elementos unidos a una clase que incluye métodos de clase y vairables

Answer 7

se escucha es más simple y funciona bajo Jython con clases 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()