Python-Liste slice Syntax ohne ersichtlichen Grund verwendet

Question

Ich sehe die Liste slice Syntax gelegentlich in Python Code wie folgt verwendet:

newList = oldList[:]

Sicher ist dies genau das gleiche wie:

newList = oldList

Oder bin ich etwas fehlt?

Answer 1

Wie NXC sagte, Python Variablennamen auf ein Objekt zeigen tatsächlich, und nicht eine bestimmte Stelle im Speicher.

newList = oldList würden zwei verschiedene Variablen erstellen, die auf das gleiche Objekt zeigen daher oldList verändern sich auch newList ändern würde.

Wenn Sie jedoch tun newList = oldList[:], es „Scheiben“ die Liste und erstellt eine neue Liste. Die Standardwerte für [:] sind 0 und das Ende der Liste, so kopiert er alles. Daher schafft es eine neue Liste mit allen Daten in der ersten enthalten ist, aber beide können ohne Änderung der anderen geändert werden.

Answer 2

[:] href="http://en.wikipedia.org/wiki/Deep_copy#Shallow_copy" rel="noreferrer"> Shallow Kopien die Liste, eine Kopie der Listenstruktur machen enthält Verweise auf die ursprüngliche Liste Mitglieder. Dies bedeutet, dass Operationen auf der Kopie nicht die Struktur der ursprünglichen beeinflussen. Wenn Sie jedoch etwas der Liste zu tun, noch beide Listen auf sie beziehen, so werden die Updates angezeigt, wenn die Mitglieder durch das Original zugegriffen werden.

tiefe Kopie würde Kopien machen alle Listenmitglieder auch.

Der Code-Schnipsel zeigt eine flache Kopie in Aktion.

# ================================================================
# === ShallowCopy.py =============================================
# ================================================================
#
class Foo:
    def __init__(self, data):
        self._data = data

aa = Foo ('aaa')
bb = Foo ('bbb')

# The initial list has two elements containing 'aaa' and 'bbb'
OldList = [aa,bb]
print OldList[0]._data

# The shallow copy makes a new list pointing to the old elements
NewList = OldList[:]
print NewList[0]._data

# Updating one of the elements through the new list sees the
# change reflected when you access that element through the
# old list.
NewList[0]._data = 'xxx'
print OldList[0]._data

# Updating the new list to point to something new is not reflected
# in the old list.
NewList[0] = Foo ('ccc')
print NewList[0]._data
print OldList[0]._data

es in einem Python-Shell Lauf gibt folgende Transkript. Wir können das sehen Liste wird mit Kopien der alten Objekte. kann eines der Objekte haben sein Zustand durch Bezugnahme durch die alte Liste aktualisiert und die Updates können sein gesehen, wenn das Objekt durch die alte Liste zugegriffen wird. Schließlich Wechsel ein Referenz in der neuen Liste nicht in der alten Liste widerspiegeln werden sehen, wie die neue Liste wird nun unter Bezugnahme auf ein anderes Objekt.

>>> # ================================================================
... # === ShallowCopy.py =============================================
... # ================================================================
... #
... class Foo:
...     def __init__(self, data):
...         self._data = data
...
>>> aa = Foo ('aaa')
>>> bb = Foo ('bbb')
>>>
>>> # The initial list has two elements containing 'aaa' and 'bbb'
... OldList = [aa,bb]
>>> print OldList[0]._data
aaa
>>>
>>> # The shallow copy makes a new list pointing to the old elements
... NewList = OldList[:]
>>> print NewList[0]._data
aaa
>>>
>>> # Updating one of the elements through the new list sees the
... # change reflected when you access that element through the
... # old list.
... NewList[0]._data = 'xxx'
>>> print OldList[0]._data
xxx
>>>
>>> # Updating the new list to point to something new is not reflected
... # in the old list.
... NewList[0] = Foo ('ccc')
>>> print NewList[0]._data
ccc
>>> print OldList[0]._data
xxx

Answer 3

Wie bereits beantwortet worden, ich werde einfach fügen Sie eine einfache Demonstration:

>>> a = [1, 2, 3, 4]
>>> b = a
>>> c = a[:]
>>> b[2] = 10
>>> c[3] = 20
>>> a
[1, 2, 10, 4]
>>> b
[1, 2, 10, 4]
>>> c
[1, 2, 3, 20]

Answer 4

denken Sie nie, dass 'a = b' in Python bedeutet 'Kopie b zu einem'. Wenn Variablen auf beiden Seiten sind, können Sie nicht wirklich wissen. Stattdessen denken sie als ‚geben b den zusätzlichen Namen a‘.

Wenn b ein unveränderliches Objekt (wie eine Nummer, Tupel oder eine Zeichenkette), dann ja, ist der Effekt, dass Sie eine Kopie erhalten. Aber das ist, denn wenn man mit immutables umgehen (was vielleicht genannt werden sollte nur lesen unveränderlich oder WORM ) Sie immer erhalten eine Kopie, per Definition.

Wenn b ein veränderliches ist, Sie muss immer tun etwas extra zu sein, dass Sie eine echte Kopie haben . immer . Mit Listen, dann ist es so einfach wie eine Scheibe: a = b [:].

Mutability ist auch der Grund, dass diese:

def myfunction(mylist=[]): 
    pass

... nicht ganz das tun, was Sie denken, es tut.

Wenn Sie von einem C-Hintergrund sind: was der ‚=‘ übrig bleibt, ist ein Zeiger, immer. Alle Variablen sind Zeiger, immer. Wenn Sie Variablen in einer Liste gesetzt: a = [b, c], haben Sie Zeiger setzen, um die Werte zu spitz von b und c in einer Liste, auf der durch ein. Wenn Sie dann ein [0] = d gesetzt ist, wird der Zeiger in Position 0 zeigt nun unabhängig von d Punkten.

Siehe auch die Kopie-Modul: http://docs.python.org/library/ copy.html

Answer 5

Shallow Copy: (Kopien Speicherblocks von einem Ort zu einem anderen)

a = ['one','two','three']

b = a[:]

b[1] = 2

print id(a), a #Output: 1077248300 ['one', 'two', 'three']
print id(b), b #Output: 1077248908 ['one', 2, 'three']

Deep Copy: (Kopien Objekt Referenz)

a = ['one','two','three']

b = a

b[1] = 2


print id(a), a #Output: 1077248300 ['one', 2, 'three']
print id(b), b #Output: 1077248300 ['one', 2, 'three']