已经有很多答案告诉你如何制作一个正确的副本，但没有一个答案说明为什么你的原始“副本”失败了。

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[：]

所有其他贡献者都给出了很好的答案，当你有一个单一维度（水平化）列表时，这些方法是有效的，但是在目前提到的方法中，只有copy.deepcopy（）可以克隆/复制列表，而当你使用多维嵌套列表（列表列表）时，它不会指向嵌套列表对象。虽然菲利克斯·克林在他的回答中提到了这一点，但这个问题还有一点问题，可能还有一个使用内置程序的解决方案，这可能会证明是深度复制的更快替代方案。

虽然new_list=old_list[：]，copy.copy（old_list）'和Py3k old_list.copy（）适用于单层列表，但它们恢复为指向嵌套在old_list和new_list中的列表对象，对其中一个列表对象的更改将在另一个列表中永久化。

编辑：新信息曝光

正如Aaron Hall和PM 2Ring所指出的那样，使用eval（）不仅是一个坏主意，而且比copy.deepcopy（）慢得多。这意味着，对于多维列表，唯一的选项是copy.deepcopy（）。尽管如此，当您尝试在中等大小的多维数组上使用它时，它确实不是一个选项，因为性能会下降。我尝试使用42x42阵列来计时，这是前所未闻的，甚至对于生物信息学应用程序来说也是如此之大，我放弃了等待响应，只是开始在这篇文章中输入我的编辑。似乎唯一真正的选择就是初始化多个列表并独立处理它们。如果有人对如何处理多维列表复制有任何其他建议，将不胜感激。

正如其他人所说的那样，在多维列表中使用copy模块和copy.devcopy存在严重的性能问题。

使用对象[：]

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

在已经给出的答案中，缺少了一个独立于python版本的非常简单的方法，您可以在大多数时间使用（至少我这样做）：

new_list = my_list * 1       # Solution 1 when you are not using nested lists

但是，如果my_list包含其他容器（例如，嵌套列表），则必须按照复制库中上述答案中的其他建议使用deepcopy。例如：

import copy
new_list = copy.deepcopy(my_list)   # Solution 2 when you are using nested lists

。奖励：如果您不想复制元素，请使用（AKA浅层复制）：

new_list = my_list[:]

让我们了解解决方案#1和解决方案#2之间的区别

>>> a = range(5)
>>> b = a*1
>>> a,b
([0, 1, 2, 3, 4], [0, 1, 2, 3, 4])
>>> a[2] = 55
>>> a,b
([0, 1, 55, 3, 4], [0, 1, 2, 3, 4])

正如您所看到的，当我们不使用嵌套列表时，解决方案#1工作得很好。让我们检查一下当我们将解决方案#1应用于嵌套列表时会发生什么。

>>> from copy import deepcopy
>>> a = [range(i,i+4) for i in range(3)]
>>> a
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> b = a*1
>>> c = deepcopy(a)
>>> for i in (a, b, c): print i
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]
>>> a[2].append('99')
>>> for i in (a, b, c): print i
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5, 99]]   # Solution #1 didn't work in nested list
[[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5]]       # Solution #2 - DeepCopy worked in nested list

new_list = my_list[:]

new_list=我的列表

试着理解这一点。假设my_list位于堆内存中的位置X，即my_list指向X。现在，通过指定new_list=my_list，可以让new_list指向X。这就是所谓的浅拷贝。

现在，如果指定new_list=my_list[：]，则只需将my_list的每个对象复制到new_list。这就是所谓的深度复制。

您可以通过以下其他方式完成此操作：

new_list=列表（old_list）导入副本new_list=复制.depcopy（old_list）