Déclaration de liste

Bonjour,
quand je déclare une liste "unidimensionnelle" (a=[0]*10), tout se passe bien.

Par contre quand je passe à une liste 'bidimensionnelle', je ne comprends plus ce qui se passe :

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

>>> a=[0]*10 >>> a [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> b=[[0]*10] >>> b [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] >>> c=[0,10]*10 >>> c [0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10, 0, 10] >>> d=[[0,10]]*10 >>> d [[0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10]] >>> d[2][0]=222 >>> d [[222, 10], [222, 10], [222, 10], [222, 10], [222, 10], [222, 10], [222, 10], [222, 10], [222, 10], [222, 10]] >>> e=[] >>> for i in range (10): ... e.append([0, 10]) ... >>> e [[0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10]] >>> e[2][0]=222 >>> e [[0, 10], [0, 10], [222, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10], [0, 10]] >>>

---

Considérons d, si je tape 'd[2][0]=222', tous les d[][0] vont avoir la valeur '222', et non seulement d[2][0]=222.

Par contre, pour 'e', tout se passe correctement.

Comment déclarer une telle structure de façon aussi concise que possible pour avoir le résultat attendu ?
Et quelle est la logique derrière un tel comportement ?

Merci pour votre aide.

Salut,

Dans la liste d tu as 10 fois la même liste (10 références à la même liste) alors que dans la liste e tu as 10 listes différentes indépendantes les unes des autres (chaque liste a sa référence).

Un code à tester pour comprendre :

Code:

---

1 2 3 4 5

a = [3] b = a print(a, b) # [3] [3] b[0] = 7 print(a, b) # [7] [7]

---

On voit que le changement de la liste b se répercute à la liste a et ce parce que a et b pointent sur la même liste.

Salut,

Citation:

---

Envoyé par jam7575

Comment déclarer une telle structure de façon aussi concise que possible pour avoir le résultat attendu ?
Et quelle est la logique derrière un tel comportement ?

---

Si j'écris:

Code:

---

1 2	>>> A = [] >>> B = [A, A, A]

---

et que je modifie A:

Code:

---

>>> A.append(1)

---

je me retrouve avec:

Code:

---

1 2 3

>>> B [[1], [1], [1]] >>>

---

Et il est "logique" de dire que si B contient 3 fois le même objet, si je modifie l'objet, la modification apparaît 3 fois. Et si je ne veux pas çà, je construis B avec 3 objets différents:

Code:

---

1 2 3 4 5 6

>>> B [[], [], [1]] >>> A.append('x') >>> B [[], [], [1, 'x']] >>>

---

Là ou vous vous faites avoir c'est avec:

Code:

---

1 2 3 4 5 6

>>> a [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> a[1] = 123 >>> a [0, 123, 0, 0, 0, 0, 0, 0, 0, 0] >>>

---

Comme un nombre n'est pas mutable/modifiable, pour changer a[1] il faut lui assigner un autre objet (et non modifier l'objet existant).

- W

merci beaucoup,
mais pourquoi le même déroulement ne vaut pas pour "a" ?

Code:

---

1 2 3 4 5

>>> a[2]=3 >>> a [0, 0, 3, 0, 0, 0, 0, 0, 0, 0] >>>

---

Cordialement.

Citation:

---

Envoyé par jam7575

mais pourquoi le même déroulement ne vaut pas pour "a" ?

---

a[2] = 3 assigne l'objet 3 à la position 2 de la liste.
On ne modifie pas l'objet en position 2 mais on en met un autre à la place.

Plus simple:

Code:

---

1 2 3 4 5 6

>> A = [] >>> B = A >>> A.append(1) >>> B [1] >>>

---

A et B sont associé à la même liste. Si je modifie la liste en y accédant par A, l'objet accédé via B montrera la modification (c'est le même).
Si j'écris:

Code:

---

1 2 3 4 5 6

>>> A = 1 >>> B = A >>> A = 2 >>> B 1 >>>

---

Ici 1 est un entier impossible à modifier (pas mutable). Si on assigne un autre entier à A, B n'a aucune raison d'être mis à jour (assigner un autre objet <=> ce ne sont plus les mêmes).

- W

Bonjour

Citation:

---

Envoyé par jam7575

Et quelle est la logique derrière un tel comportement ?

---

Python travaille à l'économie. Il en fait le minimum pour correspondre à la demande initiale. Tu as demandé dix couples (0, 10) il en a créé un seul (plus rapide que d'en créer dix différents) dont il a récupéré et stocké dix fois la référence. Au final tu obtiens bien dix couples (0, 10). Que ces dix couples soient en réalité dix références au même n'est pas en contradiction avec ta demande initiale. Tu aurais voulu dix couples différents il fallait le préciser.

Citation:

---

Envoyé par jam7575

Comment déclarer une telle structure de façon aussi concise que possible pour avoir le résultat attendu ?

---

d=[[0, 10] for i in range(10)].

Citation:

---

Envoyé par jam7575

mais pourquoi le même déroulement ne vaut pas pour "a" ?

Code:

---

1 2 3 4 5

>>> a[2]=3 >>> a [0, 0, 3, 0, 0, 0, 0, 0, 0, 0] >>>

---

---

Ecrire a[2]=3 n'est pas une modification du contenu actuel de a[2] mais une nouvelle affectation par autre chose. Tu aurais pu, dans ton premier exemple, écrire aussi d[2]=3 cela aurait aussi fonctionné. Mais d[2][0]=3 là c'est une modification de l'objet contenu dans d[2]. Et comme cet objet est aussi dans d[0] et dans d[1] et ... jusqu'à d[9]...

Autre exemple

Code:

---

1 2 3 4 5 6

>>> a=500 >>> b=a >>> id(a) 140366632449520 >>> id(b) 140366632449520

---

La copie de "b" dans "a" se fait via leurs identifiants. Au final "a" et "b" référencent le même objet "int(500)".

Code:

---

1 2 3 4 5

>>> b=500 >>> id(a) 140366632449520 >>> id(b) 140366632449488

---

Mais ensuite modifier "b", même en lui mettant la même valeur, lui affecte là un autre objet "int(500)".

Merci,
c'est très clair,
mais alambiqué.
Je crois que c'est la seconde fois que je me fais avoir avec cette 'particularité' de Python. Les années passent...
Cordialement