Discussion :

[N.tox]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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():

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

[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

[Fructidor]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[N.tox]

Ahhhh....Ok, merci à vous pour ces explications .

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Fructidor]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[N.tox]

Intéressant comme fonction... merci

[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/