Liste von Listenänderungen, die unerwartet in Unterlisten reflektiert werden

Wenn Sie [x]*3 schreiben, erhalten Sie im Wesentlichen die Liste [x, x, x] . Das heißt, eine Liste mit 3 Referenzen auf die gleiche x . Wenn Sie dann diese einzelne x ändern, ist sie über alle drei Referenzen sichtbar.

Um es zu beheben, müssen Sie sicherstellen, dass Sie an jeder Position eine neue Liste erstellen. Ein Weg, es zu tun ist

wird [1]*4 jedes Mal neu bewerten, anstatt es einmal zu bewerten und 3 Referenzen auf 1 Liste zu machen.

Sie fragen sich vielleicht, warum * keine unabhängigen Objekte so erstellen kann, wie das Listenverständnis es tut. Das liegt daran, dass der Multiplikationsoperator * auf Objekten operiert, ohne Ausdrücke zu sehen. Wenn Sie * verwenden, um [[1] * 4] mit 3 zu multiplizieren, sieht * nur die 1-Element-Liste [[1] * 4] , nicht den [[1] * 4 Ausdruckstext. * hat keine Ahnung, wie man Kopien dieses Elements erstellt, keine Idee, [[1] * 4] neu zu bewerten, und keine Ahnung, dass Sie sogar Kopien wollen, und im Allgemeinen gibt es möglicherweise keine Möglichkeit, das Element zu kopieren.

Die einzige Option * besteht darin, neue Referenzen auf die bestehende Unterliste anzulegen, anstatt neue Unterlisten zu erstellen. Alles andere wäre inkonsistent oder würde eine grundlegende Neugestaltung der grundlegenden Sprachdesign-Entscheidungen erfordern.

Im Gegensatz dazu bewertet ein Listenverständnis den Elementausdruck bei jeder Iteration neu. [[1] * 4 for n in range(3)] reevaluiert [1] * 4 jedes Mal aus demselben Grund [x**2 for x in range(3)] überprüft x**2 jedes Mal neu. Jede Auswertung von [1] * 4 erzeugt eine neue Liste, so dass das Listenverständnis funktioniert, was Sie wollen.

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

Live-Python-Lehrer visualisieren

Genau das ist genau das, was Sie erwarten würden. Lassen Sie uns zerlegen, was hier passiert:

Sie schreiben

Dies entspricht:

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

As lst[0] ist nichts als lst1 .

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

In diesem Fall wird der Ausdruck für jedes n neu ausgewertet, was zu einer anderen Liste führt.

oder sogar:

Erstellt eine Liste, die auf das interne [1,1,1,1] 3 Mal verweist - nicht auf drei Kopien der inneren Liste. Wenn Sie also die Liste (an irgendeiner Position) ändern, sehen Sie die Änderung dreimal.

Es ist das gleiche wie in diesem Beispiel:

wo es wahrscheinlich ein wenig weniger überraschend ist.

Neben der akzeptierten Antwort, die das Problem richtig erklärt hat, verwenden Sie in Ihrem Listenverständnis bei Verwendung von python-2.x xrange() , das einen effizienteren Generator zurückgibt ( range() in python 3 macht denselben Job) ) _ anstelle der Wegwerfvariablen n :

Auch als viel Pythonic Weg können Sie itertools.repeat() um ein Iterator-Objekt aus wiederholten Elementen zu erstellen:

P.S. Wenn Sie mit numpy nur ein Array von Einsen oder Nullen erstellen möchten, können Sie np.ones und np.zeros verwenden und / oder für andere Zahlen np.repeat() verwenden:

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

oder

Wichtig hierbei ist , dass der Operator * meist verwendet wird, um eine Liste von Literalen zu erstellen. Da 1 ein Literal ist, wird daher obj =[1]*4 [1,1,1,1] erzeugen, wobei jedes 1 atomar ist und nicht eine Referenz von 1 4 mal wiederholt wird. Das heißt, wenn wir obj[2]=42 machen, dann wird obj [1,1,42,1] nicht [42,42,42,42] , wie manche vielleicht annehmen.

Lassen Sie uns Ihren Code folgendermaßen schreiben:

Führen Sie dann den folgenden Code aus, um alles klarer zu machen. Was der Code tut, druckt im Grunde die id s der erhaltenen Objekte, die

  

Geben Sie die "Identität" eines Objekts zurück

und hilft uns, sie zu identifizieren und zu analysieren, was passiert:

Und Sie erhalten folgende Ausgabe:

Lasst uns jetzt Schritt für Schritt gehen. Sie haben x , was 1 ist, und eine einzelne Elementliste y , die x enthält. Ihr erster Schritt ist y * 4 , was Ihnen eine neue Liste z liefert, was im Grunde [x, x, x, x] ist, d. H. Es erstellt eine neue Liste mit 4 Elementen, die Verweise auf das ursprüngliche x -Objekt sind. Der Netto-Schritt ist ziemlich ähnlich. Sie tun im Grunde z * 3 , das ist [[x, x, x, x]] * 3 und gibt [[x, x, x, x], [x, x, x, x], [x, x, x, x]] aus dem gleichen Grund wie für den ersten Schritt zurück.

Python-Container enthalten Verweise auf andere Objekte. Siehe dieses Beispiel:

In diesem b ist eine Liste, die ein Element enthält, das eine Referenz auf die Liste a ist. Die Liste a ist änderbar.

Die Multiplikation einer Liste mit einer Ganzzahl entspricht dem mehrfachen Hinzufügen der Liste zu sich selbst (siehe gemeinsame Sequenzoperationen ). Also weiter mit dem Beispiel:

Wir können sehen, dass die Liste c jetzt zwei Referenzen enthält, um a aufzulisten, was c = b * 2 entspricht.

Python FAQ enthält auch eine Erklärung dieses Verhaltens: Wie erstelle ich eine mehrdimensionale Liste?

Ich schätze, jeder erklärt, was passiert. Ich schlage einen Weg vor, es zu lösen:

myList = [[1 for i in range(4)] for j in range(3)]

print myList

Und dann hast du:

Tatsächlich, denke es in einem anderen Fall. Angenommen, Ihre Liste enthält Folgendes:

und wenn Sie myList[0][0] = 5 output schreiben, wird

Wie Sie erwartet haben. Aber da du deine Listenvariable wie folgt definierst:

Python verarbeitet Ihre Codes in diesem Muster. Wenn Sie also myList[0][0] schreiben und Ihre Liste wie oben definiert ist, wird Python sie wie [1]*3 verarbeiten. Deshalb werden alle ersten Elemente der Liste geändert.