Bonjour, en faisant des tests j'ai remarqué que en fonction de la manière dont je créé mes listes de listes, elles ne réagissaient pas pareilles, par exemple :

>>> l = [[1]*3]*3
>>> l
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]
>>> l[0][0] = 0
>>> l
[[0, 1, 1], [0, 1, 1], [0, 1, 1]]

Alors que :

>>> l = [[1]*3,[1]*3,[1]*3]
>>> l
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]
>>> l[0][0] = 0
>>> l
[[0, 1, 1], [1, 1, 1], [1, 1, 1]]

Je ne comprends pas pourquoi, quelqu'un pourrait-il m'expliquer ? Merci

En effet je ne comprend pas très bien, et je ne pourrais pas t'aider sur ce point, et même si je le pouvais, tu vois très bien que le résultat obtenu n'est pas celui attendu.

Par contre tu peux faire dans les 2 cas cette méthode:

listes=[[1]*3]*3
for liste in listes:
    liste[0]=0

Le résultat attendu y est pour les 2 cas, je suppose donc que cette méthode fonctionne à tout les coups.

En fait moi je m'attendais plutôt au second résultat (uniquement la première valeur de la première liste modifié), peut être que j'ai trop l'habitude du C mais pour moi liste[0][0] signifie la case 0 de la case 0 de liste (la case 0 de liste étant une liste).

Les listes sont modifiables.
En faisant l = [[1]*3]*3 , tu crées une liste l qui contient trois fois la même liste alors que dans l'autre cas tu crées bien trois listes différentes.

La liste [1]*3 est enregistrée à un endroit en mémoire.
Dans le premier cas, tu crée 3 pointeurs vers la même liste, le même emplacement mémoire.
Dans le second tu prends trois place différentes.

Ps: connaissant aussi le C je pense qu'un discours avec des pointeurs te semblera plus évident.

Salut,

C'est une histoire de mémoire en effet. En Python on utilise plus volontier le terme de référence, mais au final le résultat est assez identique. Quand tu fais :

ma_liste = [[1] * 3] * 3

Tu demandes à Python de créer une liste contenant trois cases et de mettre dans ces trois cases une autre liste de la forme [1, 1, 1].

Mais ces trois cases ont la même référence : si tu en modifie une, la modification se retrouve dans les autres cases.

Ce type de notation est pratique sans aucun doute mais pas toujours clair, et en l'occurence tu arrives à un résultat qui te semble incorrect. Mieux vaut, à mon sens, utiliser du code plus compréhensible quite à ce qu'il soit plus long, que du code très compressé que tu auras plus de mal à comprendre.

Un code un peu plus simple qui met en avant ce mécanisme :

>>> liste1 = [1, 2, 3]
>>> liste2 = liste1
>>> liste2.append(4)
>>> liste2
[1, 2, 3, 4]
>>> liste1
[1, 2, 3, 4]
>>>

Pour plus d'informations, je te renvoie à mon tutoriel (quand on peut faire de la pub ), section Et les références, dans tout ça ?.

Bonne continuation, dans tous les cas

Prolixe