super(type[, object-or-type])

super() setzt man i.d.R. ein, wenn man kompliziertere Klassenhierarchien verwendet.

Wenn man eine Methode der übergeordneten Klasse überschreibt und auf die Methoden der Überklasse zugreifen möchte, gibt es zwei Möglichkeiten:

• Direktes Aufrufen der Methode anhand der Klasse:

   1 class A(object):
   2     def m(self, x):
   3         print "superclass:", x
   4 
   5 class B(A):
   6     def m(self, x):
   7         A.m(self, x)
   8         print "derived class:", x*2

• Verwendung von super:

   1 class A(object):
   2     def m(self, x):
   3         print "superclass:", x
   4 
   5 class B(A):
   6     def m(self, x):
   7         super(B, self).m(x)
   8         print "derived class:", x

Bei dieser Verwendung sucht sich super() die entsprechende Überklasse selbst heraus. Dies ist vor allem sinnvoll bei mehreren Überklassen, wie z.B. hier:

   1 class R(object) :
   2     def save(self):
   3         pass
   4 
   5 class A(R):
   6     def save(self):
   7         super(A, self).save()
   8         print "a"
   9 
  10 class B(R):
  11     def save(self):
  12         super(B, self).save()
  13         print "b"
  14 
  15 class D(B, A):
  16     def save(self):
  17         super(D, self).save()
  18         print "d"

Warum? super(Class, object) liefert aus object.__class__.mro() das auf Class folgende Element. Anhand des obigen Beispiels:

D.mro() ist die Liste (D, B, A, R, object). Wenn Du eine Instanz von D hast (nennen wir's d) und d.save aufrufst, passiert folgendes:

• Zuerst wird D.save aufgerufen.

• super(D, self) liefert B, daher wird als nächstes B.save aufgerufen.

• super(B, self) liefert A, daher wird als nächstes A.save aufgerufen.

• super(A, self) liefert R, daher wird als nächstes R.save aufgerufen.

• R.save enthält keinen super Aufruf, daher ist hier Schluss.

Wichtig dabei ist, daß in den super Aufrufen die Klasse immer Literal drinnen steht -- ein self.__class__ im Aufruf würde bei der obigen Vererbungshierarchie zu einer Endlosschleife führen.

Nachdem der literale Klassenname im super-Aufruf für manche Leute inakzeptabel ist, kann man mit Hilfe von Name Mangling eine Instanz des super-Typs als Attribut einer Klasse setzen:

   1 class Foo(object) :
   2 
   3     def save(self):
   4         pass
   5 
   6     def blah(self, x):
   7         return x
   8 
   9 class Bar(Foo):
  10 
  11     def __init__(self):
  12         self.__parent = super(Bar, self)
  13 
  14     def save(self):
  15         self.__parent.save()
  16         print "a"
  17 
  18     def blah(self, x):
  19         return self.__parent.blah(x ** 2)

Siehe Auch

Andere Seiten zum Thema findest du in den entsprechenden Tags, hier: