Python Super: eine Basisklasse Methode aufrufen, die eine andere Basisklassenmethode enthält, die von abgeleiteten Klasse außer Kraft gesetzt wird

Question

class A(object): 
    def foo(self): 
     print "A - foo" 
    def foo2(self): 
     print "foo2" 
     self.foo() 

class B(A): 
    def foo(self): 
     print "B - foo" 
    def foo2(self): 
     super(B, self).foo2() 

B().foo2() 

I [senario1] zu bekommen versuchte:

foo2 
A - foo 

bekam aber [senario2]:

foo2 
B - foo 

statt.

Ich habe the explanation gefunden, aber ich frage mich, ob es einen Weg gibt, der [senario1] ergibt, ohne den Namen der Methode foo in Klasse A zu ändern?

Answer 1

Eine Möglichkeit, dies zu tun, ist foo auf A anrufen und übergeben self, um es von Hand:

class A(object): 
    def foo(self): 
     print("A - foo") 
    def foo2(self): 
     print("foo2") 
     A.foo(self) 

class B(A): 
    def foo(self): 
     print("B - foo") 
    def foo2(self): 
     super(B, self).foo2() 

B().foo2() 

diese Weise werden Sie immer foo auf A nennen. Wenn diese foo würde self.foo() aufrufen, wenn wieder B s foo-Methode aufrufen würde. von hartzucodieren den expliziten Aufruf über A.foo und vorbei Instanz-Objekt als Argument

Answer 2

Wie Leon wies darauf hin, Sie einfach die foo Methode innerhalb der Klasse A zugreifen konnten, aber als rawing es ist nicht gut Lösung festgestellt hat. Eigentlich ist es ein Beispiel für falsches Klassen-Design. Warum?

1. Stellen Sie sich vor, dass in einem größeren Projekt, das Sie explizite Anrufe über A.foo in Hunderten von Orten verwenden würden. Versuchen Sie nun, Ihre Klasse A in MagicUnicorn umzubenennen.

2. Es ist kontraintuitiv. Wenn Sie die foo-Methode von A in B überschreiben, wird die foo von A in 99,9999% Fällen nicht benötigt, da es einen Grund geben muss, sie zu überschreiben.

Eine bessere Lösung anstatt explizite Anrufe mit wäre die foo in B umbenennen (wie rawing gesagt hat):

class A(object): 
    def foo(self): 
     print "A - foo" 
    def foo2(self): 
     print "foo2" 
     self.foo() 

class B(A): 
    def unicorn_foo(self): 
     print "B - foo" 
    def foo2(self): 
     super(B, self).foo2() 

B().foo2()