Как сказанная NXC, имена переменной Python на самом деле указывают на объект, и не определенное место в памяти.
newList = oldList
создал бы две различных переменные, которые указывают на тот же объект, поэтому, изменение oldList
также изменилось бы newList
.
Однако, когда Вы делаете newList = oldList[:]
, это "нарезает" список и создает новый список. Значения по умолчанию для [:]
0 и конец списка, таким образом, это копирует все. Поэтому это создает новый список со всеми данными, содержавшимися в первом, но оба могут быть изменены, не изменяя другой.
[:]
Мелкие копии список, делая копию структуры списка, содержащей ссылки на исходных участников списка. Это означает, что операции на копии не влияют на структуру оригинала. Однако, если Вы делаете что-то участникам списка, оба списка все еще относятся к ним, таким образом, обновления обнаружатся, если к участникам получат доступ через оригинал.
А Глубокая Копия сделала бы копии всех участников списка также.
фрагмент кода ниже показывает мелкую копию в действии.
# ================================================================
# === 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
Выполнение его в оболочке Python дает следующую расшифровку стенограммы. Мы видим, что список сделан с копиями старых объектов. Одному из объектов могла обновить его состояние ссылка через старый список, и обновления видны, когда к объекту получают доступ через старый список. Наконец, изменение ссылки в новом списке видно для не отражения в старом списке, поскольку новый список теперь относится к различному объекту.
>>> # ================================================================
... # === 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
Как этому уже ответили, я просто добавлю простую демонстрацию:
>>> 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]
Никогда не думайте, что '= b' в средствах Python 'копируют b в a'. Если существуют переменные с обеих сторон, Вы не можете действительно знать это. Вместо этого думайте о нем, поскольку 'дают b дополнительное имя a'.
, Если b является неизменным объектом (как число, кортеж или строка), то да, эффект состоит в том, что Вы получаете копию. Но поэтому когда Вы имеете дело с immutables (который, возможно, нужно было назвать только для чтения , неизменный или WORM), Вы всегда получаете копию по определению.
, Если b является изменяемым, всегда необходимо делать что-то дополнительное, чтобы быть уверенными, что у Вас всегда есть удостоверенная копия . . Со списками это столь же просто как slice:В = b [:].
Переменчивость является также причиной что это:
def myfunction(mylist=[]):
pass
... не вполне делает то, что Вы думаете, что это делает.
, Если Вы C-происхождения: то, что оставляют '=', является указателем, всегда. Все переменные являются указателями, всегда. При помещении переменных в list:В = [b, c], Вы поместили указатели на значения, на которые указывает b и c в списке, на который указывает a. Если Вы тогда устанавливаете [0] = d, указатель в положении 0 теперь указывает на любые точки d к.
См. также копию-module:В http://docs.python.org/library/copy.html
Неглубокая копия: (копирует фрагменты памяти из одного места в другое)
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']
Глубокая копия: (Копирует ссылку на объект)
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']