Puis-je utiliser une super() syntaxe Python 3 propre dans Python 2.5.6?
Peut-être avec une sorte d'importation __future__?

16
Dan Abramov 11 oct. 2011 à 01:06

4 réponses

Meilleure réponse

Vous ne pouvez pas utiliser un appel super() nu qui ne contient aucun type / classe. Vous ne pouvez pas non plus implémenter un remplacement qui fonctionnera. Python 3.x contient un support spécial pour activer les appels super() nus (il place une variable de cellule __class__ dans toutes les fonctions définies dans une classe - voir PEP 3135


Mettre à jour

Depuis Python 2.6+, les appels super() nus peuvent être utilisés via le package Python future. Voir la réponse de posita pour une explication.

15
drmuelr 12 juin 2018 à 18:34

Je me rends compte que cette question est ancienne et que la réponse sélectionnée était peut-être correcte à l'époque, mais elle n'est plus complète. Vous ne pouvez toujours pas utiliser super() dans 2.5.6, mais python-future fournit un implémentation back-portée pour 2.6+:

Installez python-future avec:

% pip install future

Ce qui suit montre la redéfinition de super sous builtins:

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

Il peut être utilisé comme suit:

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()
b.f()

Qui sort

foo
bar

Si vous utilisez pylint, vous pouvez désactiver les avertissements hérités avec le commentaire:

# pylint: disable=missing-super-argument
23
drmuelr 12 juin 2018 à 17:34

Non tu ne peux pas. Mais vous pouvez utiliser super() de Python 2 dans Python 3.

6
robert 10 oct. 2011 à 21:16

Remarque Ceci est une terrible "solution", je ne la poste que pour être sûr que vous ne le faites pas à la maison!
Je répète: ne faites pas cela

On peut penser à utiliser ce mixin

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

Pour obtenir un self.super():

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

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

Rendement:

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

Mais attention: ce self.super() n'est pas équivalent à super(B, self) - si A aussi appelé self.super().__init__(), la construction d'un B serait oblige le constructeur A à s'appeler indéfiniment, car self.__class__ restera B. Cela est dû à l'absence de la __class__ mentionnée dans la réponse acceptée. Vous pouvez éventuellement contourner ce problème avec une machine d'état masquée ou une métaclasse sophistiquée qui, par exemple. vérifie la position réelle de la classe dans self.__class__.mro(), mais cela en vaut-il vraiment la peine? Probablement pas...

3
Community 23 mai 2017 à 11:54
7718684