Wie rufe ich eine Eigenschaft der Basisklasse auf, wenn diese Eigenschaft in der abgeleiteten Klasse überschrieben wird?

Ich ändere einige meiner Klassen von einer umfangreichen Verwendung von Gettern und Setzern zu einer pythonischeren Verwendung von Eigenschaften.

Aber jetzt stecke ich fest, weil einige meiner vorherigen Getter oder Setter die entsprechende Methode der Basisklasse aufrufen und dann etwas anderes ausführen würden. Aber wie kann dies mit Eigenschaften erreicht werden? Wie rufe ich den Property Getter oder Setter in der übergeordneten Klasse auf?

Nur das Aufrufen des Attributs selbst führt natürlich zu einer unendlichen Rekursion.

class Foo(object):

    @property
    def bar(self):
        return 5

    @bar.setter
    def bar(self, a):
        print a

class FooBar(Foo):

    @property
    def bar(self):
        # return the same value
        # as in the base class
        return self.bar # --> recursion!

    @bar.setter
    def bar(self, c):
        # perform the same action
        # as in the base class
        self.bar = c    # --> recursion!
        # then do something else
        print 'something else'

fb = FooBar()
fb.bar = 7

Sie könnten denken, Sie könnten die Basisklassenfunktion aufrufen, die von der Eigenschaft aufgerufen wird:

class FooBar(Foo):

    @property
    def bar(self):
        # return the same value
        # as in the base class
        return Foo.bar(self)

Obwohl dies die naheliegendste Sache ist, denke ich - es funktioniert nicht, weil die Bar eine Eigenschaft ist, keine aufrufbare.

Eine Eigenschaft ist jedoch nur ein Objekt mit einer Getter-Methode, um das entsprechende Attribut zu finden:

class FooBar(Foo):

    @property
    def bar(self):
        # return the same value
        # as in the base class
        return Foo.bar.fget(self)

Super sollte den Trick machen:

return super().bar

In Python 2.x müssen Sie die ausführlichere Syntax verwenden:

return super(FooBar, self).bar

Es gibt eine Alternative super, bei der der Name der Basisklasse nicht explizit angegeben werden muss.

Basisklasse A:

class A(object):
    def __init__(self):
        self._prop = None

    @property
    def prop(self):
        return self._prop

    @prop.setter
    def prop(self, value):
        self._prop = value

class B(A):
    # we want to extend prop here
    pass

In B Zugriff auf den Property Getter der übergeordneten Klasse A:

Wie andere bereits geantwortet haben, ist es:

super(B, self).prop

Oder in Python 3:

super().prop

Dies gibt den vom Getter der Eigenschaft zurückgegebenen Wert zurück, nicht den Getter selbst, aber es reicht aus, den Getter zu erweitern.

Zugriff auf den Eigenschaftssetzer der übergeordneten Klasse A in B:

Die beste Empfehlung, die ich bisher gesehen habe, ist die folgende:

A.prop.fset(self, value)

Ich glaube, das ist besser:

super(B, self.__class__).prop.fset(self, value)

In diesem Beispiel sind beide Optionen gleichwertig, aber die Verwendung von Super hat den Vorteil, unabhängig von den Basisklassen von zu sein B. Wenn Sie Bvon einer CKlasse erben würden, die auch die Eigenschaft erweitert, müssten Sie den BCode nicht aktualisieren .

Vollständiger Code von B, der die Eigenschaft von A erweitert:

class B(A):
    @property
    def prop(self):
        value = super(B, self).prop
        # do something with / modify value here
        return value

    @prop.setter
    def prop(self, value):
        # do something with / modify value here
        super(B, self.__class__).prop.fset(self, value)

Eine Einschränkung:

Sofern Ihre Eigenschaft keinen Setter hat, müssen Sie sowohl den Setter als auch den Getter definieren, Bauch wenn Sie nur das Verhalten eines dieser Setter ändern.

Versuchen

@property
def bar:
    return super(FooBar, self).bar

Obwohl ich nicht sicher bin, ob Python das Aufrufen der Basisklasseneigenschaft unterstützt. Eine Eigenschaft ist eigentlich ein aufrufbares Objekt, das mit der angegebenen Funktion eingerichtet wird und dann diesen Namen in der Klasse ersetzt. Dies könnte leicht bedeuten, dass keine Superfunktion verfügbar ist.

Sie können Ihre Syntax jedoch jederzeit ändern, um die Funktion property () zu verwenden:

class Foo(object):

    def _getbar(self):
        return 5

    def _setbar(self, a):
        print a

    bar = property(_getbar, _setbar)

class FooBar(Foo):

    def _getbar(self):
        # return the same value
        # as in the base class
        return super(FooBar, self)._getbar()

    def bar(self, c):
        super(FooBar, self)._setbar(c)
        print "Something else"

    bar = property(_getbar, _setbar)

fb = FooBar()
fb.bar = 7

Einige kleine Verbesserungen an Maximes Antwort :

• Verwenden __class__, um das Schreiben zu vermeiden B. Beachten Sie, dass dies self.__class__der Laufzeittyp von selfist, __class__ ohne self jedoch der Name der umschließenden Klassendefinition. super()ist eine Abkürzung für super(__class__, self).
• Verwenden __set__statt fset. Letzteres ist spezifisch für propertys, Ersteres gilt jedoch für alle eigenschaftsähnlichen Objekte (Deskriptoren).

class B(A):
    @property
    def prop(self):
        value = super().prop
        # do something with / modify value here
        return value

    @prop.setter
    def prop(self, value):
        # do something with / modify value here
        super(__class__, self.__class__).prop.__set__(self, value)

    class Base(object):
      def method(self):
        print "Base method was called"

    class Derived(Base):
      def method(self):
        super(Derived,self).method()
        print "Derived method was called"

    d = Derived()
    d.method()

(es sei denn, ich vermisse etwas in Ihrer Erklärung)