¿Puedo usar la syntax super()
limpia de Python 3 en Python 2.5.6?
Tal vez con algún tipo de __future__
importación?
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…