我偶尔会看到 Python 代码中使用的列表切片语法，如下所示：
newList = oldList[:]
当然，这与以下内容相同：
newList = oldList
还是我错过了什么？
Charles Anderson
问问题
12065 次
5 回答
52
[:] Shallow 复制列表，复制包含对原始列表成员的引用的列表结构。这意味着对副本的操作不会影响原件的结构。但是，如果您对列表成员执行某些操作，则两个列表仍然引用它们，因此如果通过原始成员访问成员，则会显示更新。
Deep Copy也会复制所有列表成员。
下面的代码片段显示了一个浅拷贝的操作。
# ================================================================
# === 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 shell 中运行它会给出以下记录。我们可以看到列表是用旧对象的副本制作的。其中一个对象可以通过旧列表通过引用更新其状态，并且当通过旧列表访问该对象时可以看到更新。最后，可以看出更改新列表中的引用不会反映在旧列表中，因为新列表现在引用了不同的对象。
>>> # ================================================================
... # === 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
于 2008-11-27T13:00:31.973 回答
49
就像 NXC 所说，Python 变量名实际上指向一个对象，而不是内存中的特定位置。
newList = oldList将创建两个指向同一个对象的不同变量，因此，更改oldList也会更改newList。
但是，当您这样做时newList = oldList[:]，它会“切片”列表，并创建一个新列表。的默认值为[:]0 和列表的末尾，因此它会复制所有内容。因此，它创建了一个新列表，其中包含第一个列表中包含的所有数据，但两者都可以在不改变另一个的情况下进行更改。
于 2008-11-27T13:13:58.483 回答
12
正如已经回答的那样，我将简单地添加一个简单的演示：
>>> 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]
于 2008-11-27T13:40:50.487 回答
4
永远不要认为 Python 中的“a = b”意味着“将 b 复制到 a”。如果双方都有变数，你就无法真正知道这一点。相反，将其视为“给 b 附加名称 a”。
如果 b 是一个不可变对象（如数字、元组或字符串），那么是的，效果就是你得到一个副本。但那是因为当您处理不可变对象（可能应该称为read only、unchangeable或WORM）时，根据定义，您总是会得到一个副本。
如果 b 是可变的，你总是需要做一些额外的事情来确保你有一个真实的副本。总是。使用列表，它就像切片一样简单：a = b[:]。
可变性也是这个原因：
def myfunction(mylist=[]):
pass
...并没有完全按照您的想法进行。
如果您来自 C 语言背景：'=' 的左侧总是一个指针。所有变量都是指针，总是。如果你把变量放在一个列表中：a = [b, c]，你已经把指向 b 和 c 所指向的值的指针放在了 a 所指向的列表中。如果您随后设置 a[0] = d，则位置 0 中的指针现在指向 d 指向的任何内容。
于 2008-11-27T13:45:58.730 回答
-2
浅拷贝：（将内存块从一个位置复制到另一个位置）
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：（复制对象引用）
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']
于 2010-02-08T10:30:39.237 回答