Wie gebe ich in Python an, dass ich eine Methode überschreibe?

In Java bietet die @OverrideAnnotation beispielsweise nicht nur eine Überprüfung einer Überschreibung zur Kompilierungszeit, sondern sorgt auch für einen hervorragenden selbstdokumentierenden Code.

Ich suche nur nach Dokumentation (obwohl es ein Bonus ist, wenn es ein Indikator für einen Prüfer wie Pylint ist). Ich kann irgendwo einen Kommentar oder eine Dokumentzeichenfolge hinzufügen, aber wie kann eine Überschreibung in Python idiomatisch angezeigt werden?

Basierend auf dieser und der Antwort von fwc: s habe ich ein installierbares Pip-Paket https://github.com/mkorpela/overrides erstellt

Von Zeit zu Zeit schaue ich mir diese Frage an. Dies geschieht hauptsächlich, nachdem (erneut) derselbe Fehler in unserer Codebasis aufgetreten ist: Jemand hat beim Umbenennen einer Methode in der "Schnittstelle" eine Implementierungsklasse "interface" vergessen.

Nun, Python ist nicht Java, aber Python hat Macht - und explizit ist besser als implizit - und es gibt echte konkrete Fälle in der realen Welt, in denen mir dieses Ding geholfen hätte.

Hier ist eine Skizze des Overrides-Dekorateurs. Dadurch wird überprüft, ob die als Parameter angegebene Klasse denselben Methodennamen (oder einen anderen Namen) wie die zu dekorierende Methode hat.

Wenn Sie sich eine bessere Lösung vorstellen können, posten Sie diese bitte hier!

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

Es funktioniert wie folgt:

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


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

und wenn Sie eine fehlerhafte Version ausführen, wird beim Laden der Klasse ein Assertionsfehler ausgelöst:

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

>> AssertionError!!!!!!!

Hier ist eine Implementierung, für die keine Angabe des Namens der Schnittstellenklasse erforderlich ist.

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

Wenn Sie dies nur zu Dokumentationszwecken wünschen, können Sie Ihren eigenen Override-Dekorator definieren:

def override(f):
    return f


class MyClass (BaseClass):

    @override
    def method(self):
        pass

Dies ist wirklich nichts anderes als eine Augenweide, es sei denn, Sie erstellen Override (f) so, dass tatsächlich nach einem Override gesucht wird.

Aber das ist Python. Warum sollte man es so schreiben, als wäre es Java?

Python ist kein Java. Es gibt natürlich keine Überprüfung der Kompilierungszeit.

Ich denke, ein Kommentar in der Dokumentationszeichenfolge ist ausreichend. Auf diese Weise kann jeder Benutzer Ihrer Methode eingeben help(obj.method)und feststellen, dass es sich bei der Methode um eine Überschreibung handelt.

Sie können auch eine Schnittstelle explizit erweitern, mit class Foo(Interface)der Benutzer tippen können help(Interface.method), um sich ein Bild von der Funktionalität zu machen, die Ihre Methode bereitstellen soll.

Improvisieren auf @mkorpela tolle Antwort , hier ist eine Version mit

genauere Überprüfungen, Benennungen und ausgelöste Fehlerobjekte

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

So sieht es in der Praxis aus:

NotImplementedError" nicht in Basisklasse implementiert "

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

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

führt zu einem aussagekräftigeren NotImplementedErrorFehler

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

voller Stapel

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" erwarteter implementierter Typ "

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

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

führt zu einem aussagekräftigeren NotImplementedErrorFehler

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

voller Stapel

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

Das Tolle an der Antwort von @mkorpela ist, dass die Überprüfung während einer Initialisierungsphase erfolgt. Die Prüfung muss nicht "ausgeführt" werden. In Bezug auf die vorherigen Beispiele class Bwird nie initialisiert ( B()), aber der NotImplementedErrorWille wird immer noch ausgelöst. Dies bedeutet, dass overridesFehler früher erkannt werden.

Wie andere bereits gesagt haben, gibt es im Gegensatz zu Java kein @ Overde-Tag. Oben können Sie jedoch mithilfe von Dekoratoren ein eigenes Tag erstellen. Ich würde jedoch empfehlen, die globale Methode getattrib () anstelle des internen Diktats zu verwenden, damit Sie Folgendes erhalten:

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

Wenn Sie möchten, können Sie getattr () in Ihrem eigenen Versuch abfangen. Catch löst Ihren eigenen Fehler aus, aber ich denke, die Methode getattr ist in diesem Fall besser.

Außerdem werden alle an eine Klasse gebundenen Elemente erfasst, einschließlich Klassenmethoden und Vairables

Basierend auf der großartigen Antwort von @ mkorpela habe ich ein ähnliches Paket ( ipromise pypi github ) geschrieben, das viele weitere Überprüfungen durchführt:

Angenommen , Aerbt von Bund C, Berbt von C.

Das Modul ipromise überprüft Folgendes :

• Wenn A.füberschreibt B.f, B.fmuss vorhanden sein und von Aerben B. (Dies ist die Prüfung aus dem Overrides-Paket).

• Sie haben nicht das Muster A.fdeklariert, dass es überschreibt B.f, was dann deklariert, dass es überschreibt C.f. Asollte sagen, dass es überschreibt von C.fda Bkönnte entscheiden, diese Methode nicht mehr zu überschreiben, und das sollte nicht zu nachgelagerten Updates führen.

• Das Muster A.fdeklariert nicht, dass es überschrieben wird C.f, B.fdeklariert jedoch nicht, dass es überschrieben wird .

• Sie haben nicht das Muster A.fdeklariert, dass es überschreibt C.f, aber B.fdeklariert, dass es von einigen überschreibt D.f.

Es verfügt auch über verschiedene Funktionen zum Markieren und Überprüfen der Implementierung einer abstrakten Methode.

Hören ist am einfachsten und funktioniert unter Jython mit Java-Klassen:

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()

Der Dekorateur, den ich erstellt habe, hat nicht nur überprüft, ob der Name des überschreibenden Attributs in einer Oberklasse der Klasse ist, in der sich das Attribut befindet, ohne dass eine Oberklasse angegeben werden muss, sondern auch, ob das überschreibende Attribut vom selben Typ wie das überschriebene sein muss Attribut. Klassenmethoden werden wie Methoden behandelt und statische Methoden werden wie Funktionen behandelt. Dieser Dekorator arbeitet für Callables, Klassenmethoden, statische Methoden und Eigenschaften.

Quellcode finden Sie unter: https://github.com/fireuser909/override

Dieser Dekorator funktioniert nur für Klassen, die Instanzen von override.OverridesMeta sind. Wenn Ihre Klasse jedoch eine Instanz einer benutzerdefinierten Metaklasse ist, verwenden Sie die Funktion create_custom_overrides_meta, um eine Metaklasse zu erstellen, die mit dem Überschreibungsdekorator kompatibel ist. Führen Sie für Tests das Modul override .__ init__ aus.

In Python 2.6+ und Python 3.2+ können Sie dies tun ( simulieren Sie es tatsächlich , Python unterstützt keine Funktionsüberladung und die untergeordnete Klasse überschreibt automatisch die Methode der Eltern). Wir können hierfür Dekorateure verwenden. Beachten Sie jedoch zunächst, dass Pythons @decoratorsund Java @Annotationsvöllig unterschiedliche Dinge sind. Der vorherige ist ein Wrapper mit konkretem Code, während der spätere ein Flag für den Compiler ist.

Dazu zuerst 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)

Ausgabe:

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

Beachten Sie, dass Sie hier den Dekorator mit Klammern verwenden müssen

Eine Sache, an die Sie sich erinnern sollten, ist, dass Python keine direkte Funktionsüberladung hat. Selbst wenn Klasse B nicht von Klasse A erbt, sondern alle diese foobenötigt, müssen Sie auch @Override verwenden (obwohl der Alias ​​'Überladung' aussehen wird besser in diesem Fall)