Liste der Listen änderungen über Teillisten unerwartet

Beim schreiben [x]*3 erhalten Sie im wesentlichen der Liste [x, x, x]. Das heißt, eine Liste mit 3 Referenzen auf das gleiche x. Wenn Sie dann ändern diese einzelnen x es ist sichtbar über alle drei Referenzen.

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

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

wird neu zu bewerten [1]*4 jedes mal statt, bewerten Sie es einmal und machen 3 Referenzen 1 Liste.

Fragen Sie sich vielleicht, warum * kann nicht machen, unabhängige Objekte, die den Weg der list comprehension funktioniert. Das ist, weil die Multiplikation operator * arbeitet auf Objekten, ohne zu sehen, Ausdrücken. Wenn Sie * zu multiplizieren [[1] * 4] mit 3 * sieht nur das 1-element-Liste [[1] * 4] ausgewertet, nicht die [[1] * 4 expression-text. * hat keine Ahnung, wie, um Kopien des Elements, keine Ahnung, wie das zu bewerten [[1] * 4], und keine Ahnung, Sie wollen sogar kopiert, und im Allgemeinen, könnte es nicht auch ein Weg sein, um das element kopieren.

Nur die option * hat, ist zu machen, neue Hinweise auf die existierenden Teilliste, anstatt zu versuchen, um neue Teillisten. Alles andere wäre inkonsistent oder umfangreiche Neugestaltung der grundlegenden Sprache von design-Entscheidungen.

Im Gegensatz dazu eine Liste Verständnis greift das element Ausdruck auf jeder iteration. [[1] * 4 for n in range(3)] greift [1] * 4 jedes mal aus dem gleichen Grund [x**2 for x in range(3)] greift x**2 jeder Zeit. Jede Bewertung von [1] * 4 erzeugt eine neue Liste, also die Liste Verständnis hat, was Sie wollte.

Übrigens [1] * 4 auch nicht kopieren Sie die Elemente der [1], aber das spielt keine Rolle, da ganze zahlen sind unveränderlich. Können Sie nicht etwas tun, wie 1.value = 2 und drehen Sie eine 1 in eine 2.

InformationsquelleAutor CAdaker

Eigentlich ist dies genau das, was Sie erwarten würde. Wir zerlegen das, was hier geschieht:

Schreiben Sie

lst = [[1] * 4] * 3

Dies ist äquivalent zu:

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

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

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

Als lst[0] ist nichts, aber lst1.

Erhalten Sie das gewünschte Verhalten, können Sie mit list comprehension:

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

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

InformationsquelleAutor PierreBdR

Neben der akzeptierten Antwort, das erklärt das problem korrekt, in Ihrer Liste Verständnis, wenn Sie mit python-2.x verwenden Sie xrange(), liefert einen generator, der effizienter ist (range() in python 3 hat den gleichen job) _ statt der Wegwerf-variable n:

[[1]*4 for _ in xrange(3)]      # and in python3 [[1]*4 for _ in range(3)]

Auch, als viel mehr Pythonic Weise, die Sie verwenden können, itertools.wiederholen() zu erstellen, die ein iterator-Objekt der wiederholten Elemente :

>>> a=list(repeat(1,4))
[1, 1, 1, 1]
>>> a[0]=5
>>> a
[5, 1, 1, 1]

P. S. Mit numpy, wenn Sie nur wollen, erstellen Sie ein array von Einsen oder Nullen, die Sie verwenden können np.ones und np.zeros und/oder für die andere Rufnummer verwenden np.repeat():

In [1]: import numpy as np

In [2]: 

In [2]: np.ones(4)
Out[2]: array([ 1.,  1.,  1.,  1.])

In [3]: np.ones((4, 2))
Out[3]: 
array([[ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.],
       [ 1.,  1.]])

In [4]: np.zeros((4, 2))
Out[4]: 
array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]])

In [5]: np.repeat([7], 10)
Out[5]: array([7, 7, 7, 7, 7, 7, 7, 7, 7, 7])

InformationsquelleAutor Kasrâmvd

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

>>> a = []
>>> b = [a]
>>> b
[[]]
>>> a.append(1)
>>> b
[[1]]

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

Der Multiplikation einer Liste mit einem integer-äquivalent ist, um das hinzufügen der Liste, die sich mehrmals (siehe gemeinsame Sequenz von Operationen). So, weiter mit dem Beispiel:

>>> c = b + b
>>> c
[[1], [1]]
>>>
>>> a[0] = 2
>>> c
[[2], [2]]

Können wir sehen, dass die Liste c enthält jetzt zwei Verweise auf Liste a entspricht c = b * 2.

Python-FAQ enthält auch die Erklärung für dieses Verhalten: Wie erstelle ich eine mehrdimensionale Liste?

InformationsquelleAutor Zbyněk Winkler

Lassen Sie uns ändern Sie Ihren code in der folgenden Weise:

x = 1
y = [x]
z = y * 4

myList = [z] * 3

Dann mit dieser, führen Sie den folgenden code, um alles weitere klar. Was der code macht im Grunde drucken Sie die ids der erhaltenen Objekte, die

Rückkehr der "Identität" eines Objekts

und wird uns helfen, zu identifizieren und zu analysieren, was passiert:

print("myList:")
for i, subList in enumerate(myList):
    print("\t[{}]: {}".format(i, id(subList)))
    for j, elem in enumerate(subList):
        print("\t\t[{}]: {}".format(j, id(elem)))

Und Sie erhalten die folgende Ausgabe:

x: 1
y: [1]
z: [1, 1, 1, 1]
myList:
    [0]: 4300763792
        [0]: 4298171528
        [1]: 4298171528
        [2]: 4298171528
        [3]: 4298171528
    [1]: 4300763792
        [0]: 4298171528
        [1]: 4298171528
        [2]: 4298171528
        [3]: 4298171528
    [2]: 4300763792
        [0]: 4298171528
        [1]: 4298171528
        [2]: 4298171528
        [3]: 4298171528

So, jetzt lassen Sie uns gehen Sie Schritt-für-Schritt. Sie haben x die 1, und ein einzelnes element der Liste y mit x. Ihr Erster Schritt ist y * 4 die erhalten Sie eine neue Liste z ist, das im Grunde [x, x, x, x] auf, d.h. es erstellt eine neue Liste, die 4 Elemente, die Verweise auf die ersten x Objekt. Die net-step ist ziemlich ähnlich. Sie im Grunde tun z * 3, die [[x, x, x, x]] * 3 und zurück [[x, x, x, x], [x, x, x, x], [x, x, x, x]] aus dem gleichen Grund wie für den ersten Schritt.

InformationsquelleAutor bagrat

Versuchen, es zu erklären, mehr deskriptiv,

Betrieb 1:

x = [[0, 0], [0, 0]]
print(type(x)) # <class 'list'>
print(x) # [[0, 0], [0, 0]]

x[0][0] = 1
print(x) # [[1, 0], [0, 0]]

Betrieb 2:

y = [[0] * 2] * 2
print(type(y)) # <class 'list'>
print(y) # [[0, 0], [0, 0]]

y[0][0] = 1
print(y) # [[1, 0], [1, 0]]

Aufgefallen, warum nicht ändern Sie das erste element der ersten Liste nicht ändern, das zweite element von jeder Liste? Das ist, weil [0] * 2 ist wirklich eine Liste von zwei zahlen, und eine Referenz auf 0 kann nicht geändert werden.

Wenn Sie möchten, erstellen, Klonen, Kopien, versuchen Sie die Operation 3:

import copy
y = [0] * 2   
print(y)   # [0, 0]

y = [y, copy.deepcopy(y)]  
print(y) # [[0, 0], [0, 0]]

y[0][0] = 1
print(y) # [[1, 0], [0, 0]]

eine weitere interessante Möglichkeit zum erstellen von Klonen, Kopien, Operation 4:

import copy
y = [0] * 2
print(y) # [0, 0]

y = [copy.deepcopy(y) for num in range(1,5)]
print(y) # [[0, 0], [0, 0], [0, 0], [0, 0]]

y[0][0] = 5
print(y) # [[5, 0], [0, 0], [0, 0], [0, 0]]

InformationsquelleAutor Adil Abbasi