new_list = my_list[:]

new_list = my_list 尝试了解这一点。假设my_list位于X位置的堆内存中，即my_list指向X。现在，通过分配new_list = my_list，让new_list指向X。这称为浅拷贝。

现在，如果您进行分配，new_list = my_list[:]您只需将my_list的每个对象复制到new_list。这称为深拷贝。

您可以执行此操作的其他方法是：

• new_list = list(old_list)
• import copy new_list = copy.deepcopy(old_list)

令我惊讶的是尚未提及，因此出于完整性考虑...

您可以使用“ splat运算符”：进行列表解压缩*，这也会复制列表中的元素。

old_list = [1, 2, 3]

new_list = [*old_list]

new_list.append(4)
old_list == [1, 2, 3]
new_list == [1, 2, 3, 4]

该方法的明显缺点是仅在Python 3.5+中可用。

尽管在时间上比较明智，但它似乎比其他常用方法要好。

x = [random.random() for _ in range(1000)]

%timeit a = list(x)
%timeit a = x.copy()
%timeit a = x[:]

%timeit a = [*x]

#: 2.47 µs ± 38.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
#: 2.47 µs ± 54.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
#: 2.39 µs ± 58.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

#: 2.22 µs ± 43.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

已经有很多答案可以告诉您如何制作正确的副本，但是没有一个答案说明您原来的“副本”失败的原因。

Python不会将值存储在变量中。它将名称绑定到对象。您的原始任务采用了所引用的对象并将其my_list绑定到该对象new_list。无论您使用哪个名称，仍然只有一个列表，因此将其引用为时所做的更改my_list将保持不变new_list。该问题的其他每个答案都为您提供了不同的方法来创建要绑定的新对象new_list。

列表中的每个元素都像名称一样，因为每个元素都非排他地绑定到对象。浅表副本会创建一个新列表，其元素绑定到与以前相同的对象。

new_list = list(my_list)  # or my_list[:], but I prefer this syntax
# is simply a shorter way of:
new_list = [element for element in my_list]

要使列表复制更进一步，请复制列表引用的每个对象，然后将这些元素副本绑定到新列表。

import copy  
# each element must have __copy__ defined for this...
new_list = [copy.copy(element) for element in my_list]

这不是一个深层副本，因为列表的每个元素都可以引用其他对象，就像列表绑定到其元素一样。要递归复制列表中的每个元素，然后递归复制每个元素引用的其他对象，依此类推：执行深层复制。

import copy
# each element must have __deepcopy__ defined for this...
new_list = copy.deepcopy(my_list)

有关复制中极端情况的更多信息，请参见文档。

Python这样做的习惯是 newList = oldList[:]

采用 thing[:]

>>> a = [1,2]
>>> b = a[:]
>>> a += [3]
>>> a
[1, 2, 3]
>>> b
[1, 2]
>>> 

有人告诉我Python 3.3+ 增加了list.copy()方法，该方法应与切片一样快：

newlist = old_list.copy()