In Python, come posso indicare che sto sovrascrivendo un metodo?

Question

In Java, ad esempio, l'annotazione @Override non solo fornisce il controllo in fase di compilazione di una sovrascrittura, ma rende un eccellente codice di autocontrollo. Sto solo cercando la documentazione (anche se è un indicatore per alcuni checker come pylint, questo è un bonus). Posso aggiungere un commento o docstring da qualche parte, ma qual è il modo idiomatico per indicare un override in Python?

Answer 1

UPDATE (2015/05/23): Sulla base di questo e FWC: s risposta che ho creato un pacchetto installabile pip https://github.com/mkorpela/overrides

Di tanto in tanto finisco qui guardando a questa domanda. Principalmente succede dopo (di nuovo) vedere lo stesso bug nella nostra base di codice: qualcuno ha dimenticato alcune "interfacce" che implementano la classe rinominando un metodo nell'interfaccia.

Bene Python non è Java ma Python ha potere - ed esplicito è meglio che implicito - e ci sono casi concreti reali nel mondo reale in cui questa cosa mi avrebbe aiutato.

Quindi ecco uno schizzo del decoratore di overrides. Questo verificherà che la classe data come parametro abbia lo stesso metodo (o qualcosa) come metodo da decorare.

Se riesci a pensare ad una soluzione migliore, per favore postala qui!

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

Funziona come segue:

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


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

e se fate una versione difettosa esso genererà un errore di asserzione durante il caricamento della classe:

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

>> AssertionError!!!!!!! 

Answer 2

Per quanto ne so, non esiste un modo speciale per indicare un override in Python. Devi solo definire il metodo e includere una docstring, come sempre.

Answer 3

Python non è Java. Ovviamente non esiste una cosa del genere come un controllo in fase di compilazione.

Penso che un commento nella docstring sia abbondante. Ciò consente a qualsiasi utente del metodo di digitare help(obj.method) e vedere che il metodo è un override.

È inoltre possibile estendere in modo esplicito un'interfaccia con class Foo(Interface), che consentirà agli utenti di digitare help(Interface.method) per avere un'idea della funzionalità che il metodo è destinato a fornire.

Answer 4

Se si desidera che questo a scopo di documentazione unica, è possibile definire il proprio Override decoratore:

def override(f): 
    return f 


class MyClass (BaseClass): 

    @override 
    def method(self): 
     pass 

Questo non è altro che eye-candy, a meno che non si crea esclusione (f) in modo tale che sia in realtà controlla un override.

Ma allora, questo è Python, perché scrivere come se fosse Java?

Answer 5

Ecco un'implementazione che non lo fa richiede la specifica del 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 

Answer 6

Come altri hanno detto a differenza di Java non c'è tag @Overide comunque sopra potete creare i propri utilizzando decoratori tuttavia Io suggerirei di usare il getattrib() metodo globale invece di utilizzare il dict interna in modo da ottenere qualcosa di simile il seguente:

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

Se si voleva si poteva prendere getattr() nel proprio tentativo di cattura aumentare il proprio errore, ma penso che il metodo getattr è meglio in questo caso.

Anche questa cattura tutte le voci legate a una classe compresi i metodi di classe e vairables

Answer 7

sente è più semplice e operante sotto Jython con le classi 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()