Question de syntaxe: instance ou classe

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:

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 ???

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)

Citation:

Envoyé par 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)

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:

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 ???

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:

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

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

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