还有另一种方法可以复制一个直到现在才列出的列表：添加一个空列表：l2=l+[]。

我用Python 3.8测试了它：

l = [1,2,3]
l2 = l + []
print(l,l2)
l[0] = 'a'
print(l,l2)

这不是最好的答案，但它奏效了。

所有其他贡献者都给出了很好的答案，当你有一个单一维度（水平化）列表时，这些方法是有效的，但是在目前提到的方法中，只有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存在严重的性能问题。

在Python中克隆或复制列表有哪些选项？

在Python 3中，可以使用以下方法制作浅层副本：

a_copy = a_list.copy()

在Python 2和3中，您可以获得一个浅层副本，其中包含原始文件的完整切片：

a_copy = a_list[:]

解释

复制列表有两种语义方法。浅副本创建相同对象的新列表，深副本创建包含新等效对象的新的列表。

浅表副本

浅层副本仅复制列表本身，它是对列表中对象的引用的容器。如果包含的对象本身是可变的，并且其中一个对象发生了更改，则更改将反映在两个列表中。

在Python 2和3中有不同的方法来实现这一点。Python 2的方式也适用于Python 3。

Python 2

在Python 2中，制作列表的简单副本的惯用方法是使用原始列表的完整片段：

a_copy = a_list[:]

您也可以通过列表构造函数传递列表来完成相同的任务，

a_copy = list(a_list)

但是使用构造函数效率较低：

>>> timeit
>>> l = range(20)
>>> min(timeit.repeat(lambda: l[:]))
0.30504298210144043
>>> min(timeit.repeat(lambda: list(l)))
0.40698814392089844

Python 3

在Python 3中，列表获取list.copy方法：

a_copy = a_list.copy()

在Python 3.5中：

>>> import timeit
>>> l = list(range(20))
>>> min(timeit.repeat(lambda: l[:]))
0.38448613602668047
>>> min(timeit.repeat(lambda: list(l)))
0.6309100328944623
>>> min(timeit.repeat(lambda: l.copy()))
0.38122922903858125

生成另一个指针不会生成副本

使用new_list=my_list，然后在每次my_list更改时修改new_list。这是为什么？

mylist只是一个指向内存中实际列表的名称。当你说new_list=my_list时，你不是在复制，只是在添加另一个指向内存中原始列表的名称。当我们复制列表时，也会遇到类似的问题。

>>> l = [[], [], []]
>>> l_copy = l[:]
>>> l_copy
[[], [], []]
>>> l_copy[0].append('foo')
>>> l_copy
[['foo'], [], []]
>>> l
[['foo'], [], []]

列表只是指向内容的指针数组，因此浅层副本只是复制指针，因此您有两个不同的列表，但它们具有相同的内容。要复制内容，您需要一个深度副本。

深度副本

要制作列表的深度副本，在Python 2或3中，请在复制模块中使用deepcopy：

import copy
a_deep_copy = copy.deepcopy(a_list)

要演示这如何允许我们创建新的子列表：

>>> import copy
>>> l
[['foo'], [], []]
>>> l_deep_copy = copy.deepcopy(l)
>>> l_deep_copy[0].pop()
'foo'
>>> l_deep_copy
[[], [], []]
>>> l
[['foo'], [], []]

所以我们看到，深度复制的列表与原始列表完全不同。你可以滚动自己的函数，但不要。通过使用标准库的deepcopy功能，您很可能会创建一些错误。

不使用eval

你可能会看到这是一种深度复制的方式，但不要这样做：

problematic_deep_copy = eval(repr(a_list))

这是很危险的，特别是当你从一个你不信任的来源评估某件事情时。如果要复制的子元素没有一个可以求值以重现等效元素的表示，那么它就不可靠。它的性能也较差。

在64位Python 2.7中：

>>> import timeit
>>> import copy
>>> l = range(10)
>>> min(timeit.repeat(lambda: copy.deepcopy(l)))
27.55826997756958
>>> min(timeit.repeat(lambda: eval(repr(l))))
29.04534101486206

在64位Python 3.5上：

>>> import timeit
>>> import copy
>>> l = list(range(10))
>>> min(timeit.repeat(lambda: copy.deepcopy(l)))
16.84255409205798
>>> min(timeit.repeat(lambda: eval(repr(l))))
34.813894678023644

new_list=my_list实际上并没有创建第二个列表。赋值只是将引用复制到列表，而不是实际的列表，因此new_list和my_list在赋值后都引用相同的列表。

要实际复制列表，您有几个选项：

您可以使用内置的list.copy（）方法（从Python 3.3开始提供）：new_list=old_list.copy（）您可以对其进行切片：new_list=旧列表[：]亚历克斯·马特利（Alex Martelli）（至少在2007年）对此的看法是，这是一种奇怪的语法，永远使用它都没有意义（在他看来，下一篇更具可读性）。您可以使用内置的list（）构造函数：new_list=列表（old_list）您可以使用泛型copy.copy（）：导入副本new_list=复制副本（old_list）这比list（）慢一点，因为它必须首先找到old_list的数据类型。如果您还需要复制列表中的元素，请使用genericcopy.deepcopy（）：导入副本new_list=复制.depcopy（old_list）显然是最慢、最需要内存的方法，但有时不可避免。这是递归操作；它将处理任意级别的嵌套列表（或其他容器）。

例子：

import copy

class Foo(object):
    def __init__(self, val):
         self.val = val

    def __repr__(self):
        return f'Foo({self.val!r})'

foo = Foo(1)

a = ['foo', foo]
b = a.copy()
c = a[:]
d = list(a)
e = copy.copy(a)
f = copy.deepcopy(a)

# edit orignal list and instance 
a.append('baz')
foo.val = 5

print(f'original: {a}\nlist.copy(): {b}\nslice: {c}\nlist(): {d}\ncopy: {e}\ndeepcopy: {f}')

结果：

original: ['foo', Foo(5), 'baz']
list.copy(): ['foo', Foo(5)]
slice: ['foo', Foo(5)]
list(): ['foo', Foo(5)]
copy: ['foo', Foo(5)]
deepcopy: ['foo', Foo(1)]

deepcopy选项是唯一适用于我的方法：

from copy import deepcopy

a = [   [ list(range(1, 3)) for i in range(3) ]   ]
b = deepcopy(a)
b[0][1]=[3]
print('Deep:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]   ]
b = a*1
b[0][1]=[3]
print('*1:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ] ]
b = a[:]
b[0][1]=[3]
print('Vector copy:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]  ]
b = list(a)
b[0][1]=[3]
print('List copy:')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]  ]
b = a.copy()
b[0][1]=[3]
print('.copy():')
print(a)
print(b)
print('-----------------------------')
a = [   [ list(range(1, 3)) for i in range(3) ]  ]
b = a
b[0][1]=[3]
print('Shallow:')
print(a)
print(b)
print('-----------------------------')

导致输出：

Deep:
[[[1, 2], [1, 2], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
*1:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
Vector copy:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
List copy:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
.copy():
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------
Shallow:
[[[1, 2], [3], [1, 2]]]
[[[1, 2], [3], [1, 2]]]
-----------------------------

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

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)

有关复制中的角盒的详细信息，请参阅文档。