Discussion :

[chal1803]

Je débute en Python et j'écris de tous petits programmes de test pour m'aider à comprendre. Je connais assez bien, je pense, les principes OO et la manière de les coder en Java.
Mon but n'est pas de faire des comparaisons entre les principes de bases qui régissent les classes et leurs variables dans chacun des langages, chacun voit midi à sa porte ,mais je n'arrive pas à comprendre le résultat du programme suivant. Plus exactement, je ne trouve pas dans la doc. officielle Python le principe qui donnerait une explication logique au résultat de mon test:

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
 
class parent:
    # class variable
    numberOfInstance = 0
    def __init__(self, arg1):
        # an instance variable
        self._instVar1 = arg1
        parent.numberOfInstance += 1
        # self.__class__.numberOfInstance += 1
class child(parent):
    def __init__(self, arg1, arg2):
        # an instance variable for child
        self._instVar2 = arg2
        super().__init__(arg1)
p1 = parent('an arg')
p2 = parent('an arg')
p3 = child('an arg', 'another')
print(p2.numberOfInstance)
print(p3.numberOfInstance)
print(child.numberOfInstance)
print(parent.numberOfInstance)

L'exécution donne comme je m'y attendais les nombres 3, 3, 3, 3. Lorsque j'utilise self.__class__.numberOfInstance += 1 que je décommente au lieu de
parent.numberOfInstance += 1 que je commente le résultat devient

Code :

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

1
2
3
4
5
6
 
2
3
3
2
Process finished with exit code 0

Après quelques recherches, j'ai trouvé que la variable numberOfInstance est dupliquée dans la sous-classe lors de la première exécution de self.__class__.numberOfInstance += 1
lorsque la classe est de type child. Dès ce moment, il y a deux variables de classe, une dans chaque classe.
Comment expliquer par un des principes de Python que l'incrémentation, dans le cas d'un objet de type child lise la valeur dans la variable de la classe parent ,
incrémente puis écrive la nouvelle valeur dans une nouvelle variable de classe créée dans la sous classe ?
Pour moi, c'est contre-intuitif puisque la variable de classe dans child est héritée de parent, et l'accès devrait pouvoir se faire par parent ou child.
Je pense que cela a un lien avec le comportement de Python relatif à la portée des variables et aux espaces de noms, non ?
Merci par avance.

[wiztricks]

Salut,

Je pense que cela a un lien avec le comportement de Python relatif à la portée des variables et aux espaces de noms, non ?

Un espace de noms est juste une sorte de dictionnaire.
L'accès aux attributs d'une instance d'une classe (simple) va le rechercher dans 2 dictionnaires: celui de l'instance puis celui de la classe.

Si j'écris self.machin += 1, je peux très bien récupérer la valeur de machin dans le dictionnaire de la classe et stocker la nouvelle valeur dans machin du dictionnaire de l'instance (attribut/clef qui n'existait pas avant).

Plus exactement, je ne trouve pas dans la doc. officielle Python le principe qui donnerait une explication logique au résultat de mon test:

Voir le chapitre sur les classes et les espaces de noms du Python tutorial (qui fait partie de la documentation officielle).

- W

[chal1803]

Si j'écris self.machin += 1, je peux très bien récupérer la valeur de machin dans le dictionnaire de la classe et stocker la nouvelle valeur dans machin du dictionnaire de l'instance (attribut/clef qui n'existait pas avant).

Merci. Je comprends tout à fait votre exemple. Mais dans mon cas, c'est self.__class__.machin += 1. Il y a donc un 1 dictionnaire de la super classe et un de la sous classe dans
mon cas ?

[wiztricks]

Salut,

Merci. Je comprends tout à fait votre exemple. Mais dans mon cas, c'est self.__class__.machin += 1. Il y a donc un 1 dictionnaire de la super classe et un de la sous classe dans mon cas ?

Chaque classe a son "dictionnaire" (ainsi que chaque instance).
Et pour chaque objet la résolution d'un attribut se fera dans une suite de dictionnaires.

Donc si j'écris:

Code :

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

1
2
3
4
5
>>> class A:
...      machin = 'aaa'
...
>>> class B(A): pass
...

B.machin va sortir 'aaa' (qu'il a récupéré dans A.
Et B.machin += 'ZZZ' va créer machin dans B en récupérant la "valeur" de celui qu'il trouve dans A et en y ajoutant 'ZZZ'.
note: Si je crée une instance de B (b = B()), self.__class__ sera juste B (la class): plutôt que de chercher "machin" dans self puis dans B puis dans A, je saute "self".

- W

[Sve@r]

Bonjour

Comment expliquer par un des principes de Python que l'incrémentation, dans le cas d'un objet de type child lise la valeur dans la variable de la classe parent ,

Tu peux trouver un comportement similaire avec les instructions suivantes

Code Python :

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

1
2
3
4
a=123456789
b=a
print(id(a))
print(id(b))

Il y a fort à parier que tu auras deux valeurs identiques (et tu le vérifies en rajoutant print(id(a) == id(b))). Je dis "fort à parier" parce qu'il est arrivé de trouver "parfois" (exceptionnellement ?) des valeurs différentes alors qu'on s'attendait à avoir des valeurs égales (je crois qu'il y a une discussion récente à ce propos sur ce forum) mais on va mettre ça de côté.

Mais rajoute maintenant b+=1 et là tout change.

En fait, en écrivant b=a Python fait pointer la variable "b" sur la même zone mémoire que "a". C'est fait pour optimiser la copie (ok sur deux int ça ne joue pas mais si "a" est un tableau de 10000 items...) et Python travaille à l'économie. Puis si "b" doit se dissocier de "a" alors là seulement Python lui alloue une zone pour lui.

Je pense que tes tests font remonter un phénomène analogue. Tant que tu ne modifies pas l'attribut de la classe "fille", Python n'a pas besoin de le dissocier de celui de la classe "mère".

On peut aussi faire le truc suivant qui montre une chose analogue

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
class toto:
	xxx=123456
	def __init__(self, arg1):
		print(toto.xxx, id(toto.xxx))
		print(self.xxx, id(self.xxx))
		self.xxx=arg1
		print(toto.xxx, id(toto.xxx))
		print(self.xxx, id(self.xxx))
 
t=toto(234567)
print(toto.xxx, id(toto.xxx))
print(t.xxx, id(t.xxx))

Les deux premières lignes sont identiques puisque l'attribut "xxx" est pris depuis l'attribut de classe. Ensuite quand l'instance crée son "xxx", celui-ci supplante l'attribut de classe qui continue toutefois d'exister puisque les 2 dernières lignes le montrent toujours présent avec son id.

PS: pour des tests de ce genre, veille à ne pas utiliser de nombres compris entre -5 et 256 car on a remarqué que ces nombres ont toujours le même id (on pense qu'ils sont stockés en dur dans Python pour accélérer tout traitement qui les utiliserait).

[chal1803]

Puis si "b" doit se dissocier de "a" alors là seulement Python lui alloue une zone pour lui.

Salut, oui je comprends mieux la notion d'espace de noms maintenant.
Cela dit, ton premier exemple révèle plus, pour moi, la différence entre un objet et la référence qui pointe dessus.
Concernant le second, il montre bien qu'une affectation faite sur une variable va d'office ajouter la variable dans le dictionnaire courant
(l'espace de nom courant, relatif soit au self ou à la classe) si elle n'y existe pas encore.. En revanche, en "lecture" de variable, Python
cherchera la variable dans l'espace de noms courant puis cherchera dans l'espace de noms englobant, plus global, s'il elle n'est pas trouvée.
Merci

[wiztricks]

Salut,

Concernant le second, il montre bien qu'une affectation faite sur une variable va d'office ajouter la variable dans le dictionnaire courant
(l'espace de nom courant, relatif soit au self ou à la classe) si elle n'y existe pas encore.

Essayez avec:

Code :

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

1
2
3
a = 0
def f():
     a += 1

et vous verrez que variables et attributs sont différents.

- W

[Sve@r]

Cela dit, ton premier exemple révèle plus, pour moi, la différence entre un objet et la référence qui pointe dessus.

Hé oui. N'oublions pas que Python reste écrit en C. Ce qui en Python s'écrit a=[1, 2, 3, 4]; b=a se tradui(rait?) en C par int a[]={1, 2, 3, 4}; int *b=a.

Concernant le second, il montre bien qu'une affectation faite sur une variable va d'office ajouter la variable dans le dictionnaire courant
(l'espace de nom courant, relatif soit au self ou à la classe) si elle n'y existe pas encore.. En revanche, en "lecture" de variable, Python
cherchera la variable dans l'espace de noms courant puis cherchera dans l'espace de noms englobant, plus global, s'il elle n'est pas trouvée.

C'est pas mal vu

Essayez avec:

Code :

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

1
2
3
a = 0
def f():
     a += 1

Je crois qu'il faut aussi rajouter f() en dernière ligne...
Mais comme il a parlé de "lecture" cet exemple ne s'y applique pas car il implique une écriture...

[wiztricks]

Mais comme il a parlé de "lecture" cet exemple ne s'y applique pas car il implique une écriture...

On est parti de self.a += 1 où le "a" est récupéré dans la "class" et le nouvel objet associé à un "a" crée dans "l'instance".

Ce qui est cohérent avec la phrase: "Concernant le second, il montre bien qu'une affectation faite sur une variable va d'office ajouter la variable dans le dictionnaire courant".

Si l'objet de départ était mutable, pas besoin de créer une référence et donc de savoir dans quel dictionnaire créer la clef de la variable/attribut correspondant.

- W