Python attribuant plusieurs variables à la même valeur? comportement de liste

J'ai essayé d'utiliser plusieurs affectations comme indiqué ci-dessous pour initialiser les variables, mais j'ai été confus par le comportement, je m'attends à réaffecter la liste de valeurs séparément, je veux dire que b [0] et c [0] égalent 0 comme avant.

a=b=c=[0,3,5]
a[0]=1
print(a)
print(b)
print(c)

Le résultat est: [1, 3, 5] [1, 3, 5] [1, 3, 5]

Est-ce exact? que dois-je utiliser pour les affectations multiples? qu'est-ce qui est différent de cela?

d=e=f=3
e=4
print('f:',f)
print('e:',e)

résultat: ('f:', 3) ('e:', 4)

Si vous arrivez à Python à partir d'un langage du C / Java / etc. famille, cela peut vous aider à arrêter de penser à aune «variable» et à commencer à y penser comme un «nom».

a, bet cne sont pas des variables différentes avec des valeurs égales; ce sont des noms différents pour la même valeur identique. Les variables ont des types, des identités, des adresses et toutes sortes de choses comme ça.

Les noms n'ont rien de tout cela. Les valeurs le font, bien sûr, et vous pouvez avoir beaucoup de noms pour la même valeur.

Si vous offrez Notorious B.I.G.un hot-dog * Biggie Smallset Chris Wallaceun hot-dog. Si vous remplacez le premier élément de apar 1, les premiers éléments de bet csont 1.

Si vous voulez savoir si deux noms nomment le même objet, utilisez l' isopérateur:

>>> a=b=c=[0,3,5]
>>> a is b
True

Vous demandez alors:

qu'est-ce qui est différent de cela?

d=e=f=3
e=4
print('f:',f)
print('e:',e)

Ici, vous reliez le nom eà la valeur 4. Cela ne touche pas les noms det fen aucune façon.

Dans votre version précédente, vous attribuiez à a[0], pas à a. Donc, du point de vue de a[0], vous reliez a[0], mais du point de vue de a, vous le modifiez sur place.

Vous pouvez utiliser la idfonction, qui vous donne un numéro unique représentant l'identité d'un objet, pour voir exactement quel objet est lequel même si iscela ne peut pas aider:

>>> a=b=c=[0,3,5]
>>> id(a)
4473392520
>>> id(b)
4473392520
>>> id(a[0])
4297261120
>>> id(b[0])
4297261120

>>> a[0] = 1
>>> id(a)
4473392520
>>> id(b)
4473392520
>>> id(a[0])
4297261216
>>> id(b[0])
4297261216

Notez que cela a[0]est passé de 4297261120 à 4297261216 - c'est maintenant un nom pour une valeur différente. Et b[0]est également maintenant un nom pour cette même nouvelle valeur. C'est parce que aet bcontinuent de nommer le même objet.

Sous les couvertures, a[0]=1appelle en fait une méthode sur l'objet de liste. (C'est équivalent à a.__setitem__(0, 1).) Donc, ce n'est vraiment rien du tout. C'est comme appeler my_object.set_something(1). Bien sûr, l'objet est probablement en train de relier un attribut d'instance afin d'implémenter cette méthode, mais ce n'est pas ce qui est important; ce qui est important, c'est que vous n'attribuez rien, vous faites simplement muter l'objet. Et c'est la même chose avec a[0]=1.

user570826 a demandé:

Et si nous avons, a = b = c = 10

C'est exactement la même situation que a = b = c = [1, 2, 3]: vous avez trois noms pour la même valeur.

Mais dans ce cas, la valeur est an intet ints sont immuables. Dans les deux cas, vous pouvez associer aà une valeur différente (par exemple a = "Now I'm a string!"), mais n'affectera pas la valeur initiale, qui bet csera toujours des noms pour. La différence est qu'avec une liste, vous pouvez changer la valeur [1, 2, 3]en [1, 2, 3, 4]faisant, par exemple a.append(4),; puisque cela change en fait la valeur pour laquelle bet csont des noms, bva maintenant b [1, 2, 3, 4]. Il n'y a aucun moyen de changer la valeur 10en autre chose. 10a 10 pour toujours, tout comme Claudia la vampire a 5 pour toujours (du moins jusqu'à ce qu'elle soit remplacée par Kirsten Dunst).

* Attention: ne donnez pas à Notorious BIG un hot-dog. Les zombies de gangsta rap ne devraient jamais être nourris après minuit.

Tousse tousse

>>> a,b,c = (1,2,3)
>>> a
1
>>> b
2
>>> c
3
>>> a,b,c = ({'test':'a'},{'test':'b'},{'test':'c'})
>>> a
{'test': 'a'}
>>> b
{'test': 'b'}
>>> c
{'test': 'c'}
>>> 

Oui, c'est le comportement attendu. a, b et c sont tous définis comme étiquettes pour la même liste. Si vous voulez trois listes différentes, vous devez les attribuer individuellement. Vous pouvez soit répéter la liste explicite, soit utiliser l'une des nombreuses façons de copier une liste:

b = a[:] # this does a shallow copy, which is good enough for this case
import copy
c = copy.deepcopy(a) # this does a deep copy, which matters if the list contains mutable objects

Les instructions d'affectation en Python ne copient pas les objets - elles lient le nom à un objet et un objet peut avoir autant d'étiquettes que vous en définissez. Lors de votre première modification, en changeant un [0], vous mettez à jour un élément de la liste unique auquel a, b et c font tous référence. Dans votre deuxième, en changeant e, vous changez e pour être une étiquette pour un objet différent (4 au lieu de 3).

En python, tout est un objet, aussi des types de variables "simples" (int, float, etc.).

Lorsque vous modifiez la valeur d'une variable, vous modifiez en fait son pointeur , et si vous comparez entre deux variables, il compare leurs pointeurs . (Pour être clair, le pointeur est l'adresse dans la mémoire physique de l'ordinateur où une variable est stockée).

Par conséquent, lorsque vous modifiez une valeur de variable interne, vous modifiez sa valeur dans la mémoire et cela affecte toutes les variables qui pointent vers cette adresse.

Pour votre exemple, lorsque vous faites:

a = b =  5 

Cela signifie que a et b pointe vers la même adresse en mémoire qui contient la valeur 5, mais lorsque vous faites:

a = 6

Cela n'affecte pas b car a est maintenant pointe vers un autre emplacement mémoire qui contient 6 et b pointe toujours vers l'adresse mémoire qui contient 5.

Mais, quand vous faites:

a = b = [1,2,3]

a et b, encore une fois, indiquent le même emplacement, mais la différence est que si vous modifiez l'une des valeurs de la liste:

a[0] = 2

Cela change la valeur de la mémoire sur laquelle pointe a is, mais a is pointe toujours vers la même adresse que b, et par conséquent, b change également.

Vous pouvez utiliser id(name)pour vérifier si deux noms représentent le même objet:

>>> a = b = c = [0, 3, 5]
>>> print(id(a), id(b), id(c))
46268488 46268488 46268488

Les listes sont modifiables; cela signifie que vous pouvez modifier la valeur en place sans créer un nouvel objet. Cependant, cela dépend de la façon dont vous modifiez la valeur:

>>> a[0] = 1
>>> print(id(a), id(b), id(c))
46268488 46268488 46268488
>>> print(a, b, c)
[1, 3, 5] [1, 3, 5] [1, 3, 5]

Si vous attribuez une nouvelle liste a, puis son id va changer, donc il ne sera pas affecter bet cde valeurs:

>>> a = [1, 8, 5]
>>> print(id(a), id(b), id(c))
139423880 46268488 46268488
>>> print(a, b, c)
[1, 8, 5] [1, 3, 5] [1, 3, 5]

Les entiers sont immuables, vous ne pouvez donc pas modifier la valeur sans créer un nouvel objet:

>>> x = y = z = 1
>>> print(id(x), id(y), id(z))
507081216 507081216 507081216
>>> x = 2
>>> print(id(x), id(y), id(z))
507081248 507081216 507081216
>>> print(x, y, z)
2 1 1

dans votre premier exemple, a = b = c = [1, 2, 3]vous dites vraiment:

 'a' is the same as 'b', is the same as 'c' and they are all [1, 2, 3]

Si vous voulez définir 'a' égal à 1, 'b' égal à '2' et 'c' égal à 3, essayez ceci:

a, b, c = [1, 2, 3]

print(a)
--> 1
print(b)
--> 2
print(c)
--> 3

J'espère que cela t'aides!

En termes simples, dans le premier cas, vous attribuez plusieurs noms à un list . Une seule copie de la liste est créée en mémoire et tous les noms font référence à cet emplacement. Ainsi, changer la liste en utilisant l'un des noms modifiera en fait la liste en mémoire.

Dans le second cas, plusieurs copies de même valeur sont créées en mémoire. Ainsi, chaque copie est indépendante l'une de l'autre.

Voici ce dont vous avez besoin:

a, b, c = [0,3,5] # Unpack the list, now a, b, and c are ints
a = 1             # `a` did equal 0, not [0,3,5]
print(a)
print(b)
print(c)

Le code qui fait ce dont j'ai besoin pourrait être le suivant:

# test

aux=[[0 for n in range(3)] for i in range(4)]
print('aux:',aux)

# initialization

a,b,c,d=[[0 for n in range(3)] for i in range(4)]

# changing values

a[0]=1
d[2]=5
print('a:',a)
print('b:',b)
print('c:',c)
print('d:',d)

Résultat:

('aux:', [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]])
('a:', [1, 0, 0])
('b:', [0, 0, 0])
('c:', [0, 0, 0])
('d:', [0, 0, 5])