¿Puedo usar Python 3 super () en Python 2.5.6?

No puede usar una llamada super() simple que no contenga ningún tipo / clase. Tampoco puede implementar un reemplazo que funcione. Python 3.x contiene soporte especial para habilitar las llamadas super() (coloca una variable de celda __class__ en todas las funciones definidas dentro de una clase – vea PEP 3135

Actualizar

A partir de Python 2.6+, las llamadas super() se pueden usar a través del future paquete de Python. Vea la respuesta de posita para una explicación.

Me doy cuenta de que esta pregunta es antigua y que la respuesta seleccionada pudo haber sido correcta en ese momento, pero ya no está completa. Aún no puedes usar super() en 2.5.6, pero python-future proporciona una implementación de puerto posterior para 2.6+:

Instala python-future con:

 % pip install future 

A continuación se muestra la redefinición de super under builtins :

 % python ... >>> import sys >>> sys.version_info[:3] (2, 7, 9) >>> >>> super  >>> >>> from builtins import * >>> super  >>> super.__module__ 'future.builtins.newsuper' 

Se puede utilizar de la siguiente manera:

 from builtins import super class Foo(object): def f(self): print('foo') class Bar(Foo): def f(self): super().f() # <- whoomp, there it is print('bar') b = Bar() bf() 

que salidas

 foo bar 

Si usa pylint , puede deshabilitar las advertencias heredadas con el comentario:

 # pylint: disable=missing-super-argument 

No, no puedes. Pero puedes usar el super() de Python 2 en Python 3.

Nota Esta es una “solución” terrible, la publico solo para asegurarme de que no haga esto en casa.
Repito: no hagas esto

Uno puede pensar en usar esta mezcla.

 class Super(object): def super(self): return super(self.__class__, self) 

para obtener un self.super() :

 class A(object, Super): def __init__(self): print "A" class B(A): def __init__(self): print "B" self.super().__init__() 

flexible:

  >>> a = A() A >>> b = B() B A 

Pero cuidado: este self.super() no es equivalente a super(B, self) ; si A también se llama self.super().__init__() , la construcción de B hará que el constructor A llame a sí mismo de forma indefinida, ya que self.__class__ permanecerá B Esto se debe a la falta de la __class__ mencionada en la respuesta aceptada . Posiblemente pueda solucionar este problema con una máquina de estado oculta o una metaclase sofisticada que, por ejemplo, verifique la posición de la clase real en self.__class__.mro() , pero ¿realmente vale la pena? Probablemente no…