Discussion :

[rambc]

Le code suivant me surprend un peu.

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
#coding=utf-8
 
class test(object):
    def __init__(self, text):
        self.text = text
        self.etrange = 'ok'
    def __str(self):
        return self.text
 
dicoClass = {}
dicoClass['o'] = test('oo')
a = dicoClass['o']
a.etrange = 'testons'
b = dicoClass['o']
print "b.etrange == a.etrange"
print b.etrange
 
dicoChaine = {}
dicoChaine['o'] = 'oo'
c = dicoChaine['o']
c = 'non'
d = dicoChaine['o']
print "d <> c"
print d

Ceci donne à la sortie :

Code :

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

1
2
3
4
b.etrange == a.etrange
testons
d <> c
oo

Ce que je voudrais c'est avoir pour b une nouvelle instance qui aura bien la valeur par défaut de b .etrange. Comment faire sachant que j'ai absoluement besoin de travailler avec des dictionnaires de classes ?
Au passage, pourquoi ce comportement sinueux de Python ?

[rambc]

Un petit coup de Google et voici une méthode possible :

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
#!/usr/bin/env python
#coding=utf-8
 
# Source : http://docs.python.org/library/copy.html
import copy
 
class test(object):
    def __init__(self, text):
        self.text = text
        self.etrange = 'ok'
    def __str(self):
        return self.text
 
newDicoClass = {}
newDicoClass['o'] = test('oo')
newA = copy.deepcopy(newDicoClass['o'])
newA.etrange = 'testons'
newB = copy.deepcopy(newDicoClass['o'])
print "newB.etrange <> newA.etrange"
print newB.etrange

Quelqu'un pourrait-il m'expliquer ce comportement sinueux de Python.

[oiffrig]

Comme souvent, une histoire de référence. Je m'explique :

Code :

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

newDicoClass['o'] = test('oo')

On crée une instance de test et on la met dans le dictionnaire.

Code :

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

a = dicoClass['o']

On place dans a une référence vers l'instance.

Code :

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

newA.etrange = 'testons'

On modifie un attribut de la référence.

Code :

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

b = dicoClass['o']

On reprend une référence vers la même instance, on la nomme b.

Code :

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

print b.etrange

Nous donne bien le résultat prévu, puisque a et b sont des références vers le même objet.

Je ne vais pas décortiquer la deuxième partie, mais une affectation change l'objet vers lequel c pointe.

On peut s'en assurer en utilisant la fonction id (donne un identifiant unique de la référence, en général l'adresse mémoire), ou le mot-clé is (True si et seulement si les deux références pointent vers le même objet).

Le comportement général de Python est que tout est passé par référence. Si tu passes une instance d'une classe quelconque en paramètre d'une fonction, et que dans cette fonction tu modifies l'instance (sans réaffecter), elle sera modifiée en dehors aussi.
à chaque affectation tu fais en fait des références. Ainsi, si tu fais dans ton code a = b, a et b seront des références vers le même objet, tant que tu ne réaffecteras pas l'une des deux.

[rambc]

Nous donne bien le résultat prévu, puisque a et b sont des références vers le même objet.

Oui mais que dire du code suivant :

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
#!/usr/bin/env python
#coding=utf-8
 
class test(object):
    def __init__(self, text):
        self.text = text
        self.etrange = 'ok'
    def __str(self):
        return self.text
 
dicoClass = {}
dicoClass['o'] = test('oo')
a = dicoClass['o']
dicoClass['o'].etrange = 'testons'
print a.etrange
 
dicoChaine = {}
dicoChaine['o'] = 'oo'
c = dicoChaine['o']
dicoChaine['o'] += 'rr'
print c
print dicoChaine['o']

c n'a pas été modifié... Du coup ton explication me convainc pas trop. J'ai testé le code suivant :

Code :

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

1
2
3
4
5
6
7
8
#!/usr/bin/env python
#coding=utf-8
 
dicoClass = {}
dicoClass['o'] = [0, 1, 2]
a = dicoClass['o']
dicoClass['o'][1] = 'testons'
print a

Et là je me suis souvenu de la façon dont Python copie les listes, les dicos... ie tous les objets dont on peut modifier des "morceaux" (contrairement aux variables de type chaîne dont on ne peut pas modifier directement un caractère). Du coup, l'explication doit être de ce côté, à savoir que dicoClass est modifiable par "morceaux".

[oiffrig]

Ton interprétation est presque la bonne. En fait Python fait toujors des références, mais ça ne se voit pas avec certains types de base (int, float, complex, str, tuple, ...) car ils sont immuables, c'est-à-dire que les "modifier" revient en fait à recréer un objet. Tu peux, une fois de plus, t'en convaincre avec la fonction id ou le mot-clé is.

[rambc]

Merci mes idées s'éclaircissent. Qu'en j'ai posté ma question j'étais un peu en stress car je suis sur un projet amateur important avec beaucoup de lignes de codes et je craignais que la clé de voûte de mon application soit détruite.