Unerwartete Änderungen an der Liste der Listen in den Unterlisten

Question

Ich musste eine Liste von Listen in Python erstellen, also tippte ich das Folgende ein:

my_list = [[1] * 4] * 3

Die Liste sah wie folgt aus:

[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]  

Dann habe ich einen der innersten Werte geändert:

my_list[0][0] = 5

Jetzt sieht meine Liste wie folgt aus:

[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]  

was nicht das ist, was ich wollte oder erwartet hatte. Kann mir bitte jemand erklären, was hier los ist und wie man das Problem umgehen kann?

Answer 1

Wenn Sie schreiben [x]*3 erhalten Sie im Wesentlichen die Liste [x, x, x] . Das heißt, eine Liste mit 3 Verweisen auf denselben x . Wenn Sie dann diese einzelne Änderung x sie ist durch alle drei Verweise auf sie sichtbar:

x = [1] * 4
l = [x] * 3
print(f"id(x): {id(x)}")
# id(x): 140560897920048
print(
    f"id(l[0]): {id(l[0])}\n"
    f"id(l[1]): {id(l[1])}\n"
    f"id(l[2]): {id(l[2])}"
)
# id(l[0]): 140560897920048
# id(l[1]): 140560897920048
# id(l[2]): 140560897920048

x[0] = 42
print(f"x: {x}")
# x: [42, 1, 1, 1]
print(f"l: {l}")
# l: [[42, 1, 1, 1], [42, 1, 1, 1], [42, 1, 1, 1]]

Um dies zu beheben, müssen Sie sicherstellen, dass Sie an jeder Position eine neue Liste erstellen. Eine Möglichkeit, dies zu tun, ist

[[1]*4 for _ in range(3)]

die eine Neubewertung vornehmen wird [1]*4 jedes Mal, anstatt es einmal auszuwerten und 3 Verweise auf 1 Liste zu machen.

---

Sie fragen sich vielleicht, warum * kann keine unabhängigen Objekte erzeugen, wie es das Listenverständnis tut. Das liegt daran, dass der Multiplikationsoperator * wirkt auf Objekte, ohne Ausdrücke zu sehen. Wenn Sie * zu multiplizieren [[1] * 4] von 3, * sieht nur die 1-Element-Liste [[1] * 4] auswertet, nicht die [[1] * 4 Ausdruckstext. * keine Ahnung hat, wie man Kopien von diesem Element anfertigt, keine Ahnung, wie man es neu bewertet [[1] * 4] und keine Ahnung, dass Sie überhaupt Kopien wollen, und im Allgemeinen gibt es vielleicht nicht einmal eine Möglichkeit, das Element zu kopieren.

Die einzige Möglichkeit * besteht darin, neue Verweise auf die bestehende Teilliste zu erstellen, anstatt zu versuchen, neue Teillisten zu erstellen. Alles andere wäre inkonsistent oder würde eine umfassende Umgestaltung grundlegender Entscheidungen zum Sprachdesign erfordern.

Im Gegensatz dazu wird bei einem Listenverständnis der Elementausdruck bei jeder Iteration neu ausgewertet. [[1] * 4 for n in range(3)] bewertet neu [1] * 4 jedes Mal aus demselben Grund [x**2 for x in range(3)] bewertet neu x**2 jedes Mal. Jede Bewertung von [1] * 4 erzeugt eine neue Liste, so dass das Listenverständnis das tut, was Sie wollten.

Im Übrigen, [1] * 4 kopiert auch nicht die Elemente von [1] aber das spielt keine Rolle, da Ganzzahlen unveränderlich sind. Sie können nicht etwas tun wie 1.value = 2 und verwandeln eine 1 in eine 2.

Answer 2

size = 3
matrix_surprise = [[0] * size] * size
matrix = [[0]*size for _ in range(size)]

Live-Visualisierung mit Python Tutor:

Answer 3

Eigentlich ist das genau das, was man erwarten würde. Lassen Sie uns aufschlüsseln, was hier passiert:

Sie schreiben

lst = [[1] * 4] * 3

Dies ist gleichbedeutend mit:

lst1 = [1]*4
lst = [lst1]*3

Dies bedeutet lst ist eine Liste mit 3 Elementen, die alle auf lst1 . Das bedeutet, dass die beiden folgenden Zeilen gleichwertig sind:

lst[0][0] = 5
lst1[0] = 5

Como lst[0] ist nichts anderes als lst1 .

Um das gewünschte Verhalten zu erreichen, können Sie ein Listenverständnis verwenden:

lst = [ [1]*4 for n in range(3) ]

In diesem Fall wird der Ausdruck für jede n und führt zu einer anderen Liste.

Answer 4

[[1] * 4] * 3

oder sogar:

[[1, 1, 1, 1]] * 3

Erzeugt eine Liste, die auf die interne [1,1,1,1] 3 Mal - nicht drei Kopien der inneren Liste, d. h. jedes Mal, wenn Sie die Liste (an einer beliebigen Stelle) ändern, sehen Sie die Änderung drei Mal.

Es ist dasselbe wie in diesem Beispiel:

>>> inner = [1,1,1,1]
>>> outer = [inner]*3
>>> outer
[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]
>>> inner[0] = 5
>>> outer
[[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]

wo es wahrscheinlich etwas weniger überraschend ist.

Answer 5

my_list = [[1]*4] * 3 erstellt ein Listenobjekt [1,1,1,1] im Speicher und kopiert seine Referenz 3 Mal. Dies ist gleichbedeutend mit obj = [1,1,1,1]; my_list = [obj]*3 . Jede Änderung an obj wird an drei Stellen reflektiert, wo immer obj wird in der Liste referenziert. Die richtige Aussage wäre:

my_list = [[1]*4 for _ in range(3)]

o

my_list = [[1 for __ in range(4)] for _ in range(3)]

Ein wichtiger Punkt ist hier zu beachten ist, dass die * Betreiber ist meist verwendet, um eine Liste von Literalen . Obwohl 1 unveränderlich ist, obj = [1]*4 wird weiterhin eine Liste von 1 4 Mal wiederholt, um zu bilden [1,1,1,1] . Wenn jedoch ein Verweis auf ein unveränderliches Objekt erfolgt, wird das Objekt mit einem neuen überschrieben.

Das heißt, wenn wir obj[1] = 42 entonces obj werden [1,42,1,1] pas [42,42,42,42] wie manche vielleicht annehmen. Dies kann auch überprüft werden:

>>> my_list = [1]*4
>>> my_list
[1, 1, 1, 1]

>>> id(my_list[0])
4522139440
>>> id(my_list[1])  # Same as my_list[0]
4522139440

---

>>> my_list[1] = 42  # Since my_list[1] is immutable, this operation overwrites my_list[1] with a new object changing its id.
>>> my_list
[1, 42, 1, 1]

>>> id(my_list[0])
4522139440
>>> id(my_list[1])  # id changed
4522140752
>>> id(my_list[2])  # id still same as my_list[0], still referring to value `1`.
4522139440