Discussion :

[Sve@r]

Bonjour

Je me demandais aujourd'hui s'il valait mieux appeler une sous classe par l'instance de classe ou bien par son nom générique

Exemple

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
#!/usr/bin/env python
class cParent1:
    def __init__(self, val):
        self.enfant=self.cEnfant(val)
 
    class cEnfant:
        def __init__(self, val):
            self.val=val
 
class cParent2:
    def __init__(self, val):
        self.enfant=cParent2.cEnfant(val)
 
    class cEnfant:
        def __init__(self, val):
            self.val=val
 
p1=cParent1(12)
p2=cParent2(25)

J'ai fait plein d'affichage, j'ai aussi affiché les del voir si je perdais qqchose mais je n'ai vu aucune différence entre p1 et p2. Quelqu'un aurait-il des conseils là-dessus ???

[oiffrig]

Tout dépend de ce que tu veux en faire.

Il faut savoir que si tu utilises ta première méthode, la classe enfant pourrait ne pas être la même pour chaque parent (ici, peu importe vu que tu t'en sers uniquement dans le constructeur, mais il faut y penser)

[Sve@r]

Tout dépend de ce que tu veux en faire.

Il faut savoir que si tu utilises ta première méthode, la classe enfant pourrait ne pas être la même pour chaque parent (ici, peu importe vu que tu t'en sers uniquement dans le constructeur, mais il faut y penser)

Euh, je n'arrive pas trop à comprendre quelle différence cela fera même si je crée l'enfant ailleurs que dans le init voire même en créant plusieurs enfants. Mais je sens que mon exemple a été mal construit. Je n'ai pas 2 classes parents, je n'en ai qu'une mais elle a 2 façons d'appeler un enfant.

Voici un autre exemple qui se rapproche plus de mon interrogation

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
#!/usr/bin/env python
class cParent:
    def __init__(self):
        self.tabEnfant1=[]
        self.tabEnfant2=[]
 
    def create1(self, val):
        for i in range(val):
            self.tabEnfant1.append(self.cEnfant(i))
 
    def create2(self, val):
        for i in range(val):
            self.tabEnfant2.append(cParent.cEnfant(i))
 
     class cEnfant:
        def __init__(self, val):
            self.val=val
 
p=cParent()
p.create1(12)
p.create2(25)
for fils in p.tabEnfant1:
    print fils.val
for fils in p.tabEnfant2:
    print fils.val

Cela fait-il une différence pour tabEnfant1 et tabEnfant2 ???

[Thierry Chappuis]

Je n'ai pas investigué la question à fond, mais à priori, dans le cas qu tu présente ici, cela ne fait aucune différence, sauf si cParent possède une variable d'instance appelée cEnfant:

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
class cParent(object):
    def __init__(self):
        self.tabEnfant1=[]
        self.tabEnfant2=[]
        self.cEnfant = 0
 
    def create1(self, val):
        for i in range(val):
            self.tabEnfant1.append(self.cEnfant(i))
 
    def create2(self, val):
        for i in range(val):
            self.tabEnfant2.append(cParent.cEnfant(i))
 
    class cEnfant(object):
        def __init__(self, val):
            self.val=val

Dans ce cas, l'appel à create2() fonctionne mais pas l'appel à create1() (car maintenant, self.cEnfant fait référence à un objet non appelable). Mais bon, en appliquant des normes de nommage claires, il n'y a en principe aucune raison pour se retrouver dans cette situation.

Thierry

[oiffrig]

Voilà un code qui illustre ce que j'expliquais :

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
class cParent:
    def __init__(self):
        self.tabEnfant1 = []
        self.tabEnfant2 = []
 
    def create1(self, val):
        self.tabEnfant1.append(self.cEnfant(val))
 
    def create2(self, val):
        self.tabEnfant2.append(cParent.cEnfant(val))
 
    class cEnfant:
        def __init__(self, val):
            self.val = val
            print "Constructeur normal, val = %s" % val
 
class cEnfant2:
    def __init__(self, val):
        self.val = val
        print "Constructeur modifié, val = %s" % val
 
p=cParent()
p.create1(12)
p.create2(25)
p.cEnfant = cEnfant2
p.create1(13)
p.create2(26)
 
for fils in p.tabEnfant1:
    print fils.val
for fils in p.tabEnfant2:
    print fils.val