Utilité de super()

Version imprimable

06/10/2008, 02h06
N.tox

Utilité de super()
salut tous,

J'ai commencé y'a quelque heures à jeter un coup d'oeil quant à la manière de se servir de PyQt, ma question ne porte pas sur Qt, mais sur la signification de l'utilisation de super(), je ne comprend pas :?... J'ai lu la doc de python.org sur cette fonction, mais... rien à faire, je crois capté vaguement le but, mais le pourquoi du comment m'échappe totalement...

voici le bout de code en question :
Code:

1 2 3 class Form(QDialog): def __init__(self, parent=None): super(Form, self).__init__(parent)
ainsi que l'explication du supposé cas de figure de l'utilisation de super():

Citation:

There are two typical use cases for “super”. In a class hierarchy with single inheritance, “super” can be used to refer to parent classes without naming them explicitly, thus making the code more maintainable. This use closely parallels the use of “super” in other programming languages.

D'après ce j'ai cru comprendre, dans ce cas ce serait utilisé dans cet exemple pour lancer la méthode __init__ de la classe parente... mais plusieurs fois, j'ai vu une façon différente de procéder (dans des exmple pour Tkinter, mais peu importe, le fait est que dans mes souvenirs, ça m'avait l'air plus simple...)
Voilà, si quelqu'un voulait bien m'expliquer le but et le fonctionnement de super(), ce serait sympa, merci :)
06/10/2008, 08h10
Guigui_

la fonction super permet d'appeler une fonction de la classe mère. Cela est utile si la classe enfant redéfinit la même fonction (que celle de la classe mère) mais qu'on veut tout de même utiliser celle de la classe mère. Si la classe fille ne redéfinit pas la fonction de la classe mère, il n'y a pas besoin d'utiliser la fonction super.

Un exemple ici:
http://python.developpez.com/faq/?pa...utableHeritage

En effet, super permet d'appeler une méthode surchargée, mais pas nécessairement celle de la classe mère. Je m'explique.

En fait, super(c,i) retourne un proxy de la classe qui suit c dans le mro de i. Le mro, c'est la liste ordonnée de la hiérarchie d'une classe. Tout ca ne marche qu'avec des classes "new style" (dérivent toutes d'object)
Code:

1 2 3 4 5 6 7 8 9 class A(object): def x(self): print 'a' class B(A): def x(self): print 'b' >>> B().x() b >>> super(B,B()).x() a
Dans le cas d'un heritage simple, utiliser super ou la classe mère ne fait pas de différence. A la rigueur, c'est plus maintenable (et encore).

Par contre, si on prend une hierarchie en diamant:

A
/ \
B C
\ /
D
Code:

1 2 3 4 5 6 7 8 9 class C(A): def x(self):print 'c' class D(B,C): def x(self): print 'd' >>> import inspect >>> inspect.getmro(D) (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <type 'object'>)
Et on a (oh surprise!):
Code:

1 2 3 >>> super(B,D()).x() c
Au lieu de a. L'interet est de n'appeler qu'une fois la méthode de la classe A, et d'appeler les méthodes dans le bon ordre.
Le problème de super est d'une part le passage d'argument (il faut que tous les arguments soient compatibles) et d'autre part que super soit utilisé systématiquement dans toutes les classes.

06/10/2008, 13h41
N.tox
Ahhhh....Ok, merci à vous pour ces explications :D.

Toutefois, j'ai encore une question, enfin plus une requête de confirmation pour voir si j'ai bien compris...

Dans le cas d'une hiérarchie en diamant juste un poil plus grosse que celle que tu m'as montré Fructidor :
Code:

1 2 3 4 5 6 7 A /|\ B C D \|/ E #ou E hériterait dans l'ordre de (B,C,D), et D de (A)
les connections en quelque sortes, lors de l'appel de la méthode x via un super object, pourrait se shématiser de la sorte :
Code:

1 2 3 4 5 6 7 A | B-C-D | E #Dans le cas de test d'appel de la méthode x via super(y,E()).x() pour y in (E,B,C,D)
C'est bien ça ?

Oui, c'est à dire que si toutes les classes possédaient une méthode qui appellerait super(self,...) ou ... serait remplacé par la classe, alors les méthodes seraient appelées dans cet ordre.

Voici un exemple pour __init__ avec une façon de gérer le problème des arguments:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
class A(object):
    def __init__(self,*args,**kwargs):
        toto=kwargs.pop('toto')
        print 'a',toto
        super(A,self).__init__(*args,**kwargs)
 
 
class B(A):
    def __init__(self,*args,**kwargs):
        print 'b'
        super(B,self).__init__(*args,**kwargs)
 
class C(A):
    def __init__(self,*args,**kwargs):
        print 'c'
        super(C,self).__init__(*args,**kwargs)
 
class D(A):
    def __init__(self,*args,**kwargs):
        print 'd'
        super(D,self).__init__(*args,**kwargs)
 
class E(B,C,D):
    def __init__(self,*args,**kwargs):
        print 'e'
        super(E,self).__init__(*args,**kwargs)
 
>>> e=E(toto='un argument')
e
b
c
d
a un argument

06/10/2008, 16h50
N.tox

Intéressant comme fonction... merci :king:
01/03/2018, 17h45
Stash of Code

Explications en français sur le fonctionnement interne de super (), qui ne se limite pas simplement à résoudre le problème de la résolution de l'appel à une méthode surchargée dans une configuration en diamant :

http://www.stashofcode.fr/comment-ma...per-de-python/