En supposant que `obj` a le type` objtype`, sont `super (cls, obj)` et `super (cls, objtype)` identiques?

Question

En Python, en supposant que obj a le type objtype, sont super(cls,obj) et super(cls,objtype) le même?

Est-il exact que super(cls,obj) convertit obj à un autre objet dont la classe est une superclasse de objtype qui est après cls dans la MRO de objtype?

Que signifie super(cls,objtype) alors?

---

Par exemple, étant donné une mise en œuvre du modèle de conception Singleton:

class Singleton(object): 
    _singletons = {} 
    def __new__(cls, *args, **kwds): 
     if cls not in cls._singletons: 
      cls._singletons[cls] = super(Singleton, cls).__new__(cls) 
     return cls._singletons[cls] 

une sous-classe de Singleton (qui n'a pas encore outrepasser __new__) a exactement une instance.

Que signifie super(Singleton, cls), où cls est une classe? Que retourne-t-il?

Merci.

Answer 1

Selon le docs, super

Retour un objet proxy méthode délégués appelle à un parent ou une classe de type frères et soeurs.

Donc super renvoie un objet qui sait comment appeler les méthodes d'autres classes de la hiérarchie de classe.

Le deuxième argument à super est l'objet auquel super est lié; généralement c'est une instance de la classe, mais si super est appelée dans le contexte d'une méthode qui est un classmethod ou staticmethod alors nous voulons appeler la méthode sur l'objet de classe lui-même plutôt qu'une instance.

Donc, appeler super(SomeClass, cls).some_method() signifie que l'appel some_method sur les cours que SomeClass descend de, plutôt que sur cas de ces classes. Sinon, les appels super se comportent comme un appel super dans une méthode d'instance.

L'utilisation semble plus naturel dans le code moins compliqué:

class C(SomeBaseClass): 

    def method(self): 
     # bind super to 'self' 
     super(C, self).method() 

    @classmethod 
    def cmethod(cls): 
     # no 'self' here -- bind to cls 
     super(C, cls).cmethod() 

Notez que super(C, cls) est nécessaire python2, mais un super() vide est assez python3. Dans votre exemple Singleton, super(Singleton, cls).__new__(cls) renvoie le résultat de l'appel object.__new__(cls), une instance de Singleton. Il est créé de cette façon pour éviter d'appeler récursivement Singleton.__new__.