框架挑战：对于您的应用程序，您实际上需要复制吗？

我经常看到试图以某种迭代方式修改列表副本的代码。为了构造一个简单的示例，假设我们有非工作（因为不应该修改x）代码，如：

x = [8, 6, 7, 5, 3, 0, 9]
y = x
for index, element in enumerate(y):
    y[index] = element * 2
# Expected result:
# x = [8, 6, 7, 5, 3, 0, 9] <-- this is where the code is wrong.
# y = [16, 12, 14, 10, 6, 0, 18]

自然，人们会问如何使y成为x的副本，而不是同一列表的名称，这样for循环就会做正确的事情。

但这是错误的做法。从功能上讲，我们真正想做的是在原始列表的基础上创建一个新列表。

我们不需要先做一份拷贝，通常也不应该。

当我们需要对每个元素应用逻辑时

这方面的自然工具是列表理解。这样，我们编写逻辑，告诉我们期望结果中的元素如何与原始元素相关联。它简单、优雅、富有表现力；并且我们避免了在for循环中修改y副本的需要（因为分配给迭代变量不会影响列表-原因与我们首先想要副本的原因相同！）。

对于上面的示例，它看起来像：

x = [8, 6, 7, 5, 3, 0, 9]
y = [element * 2 for element in x]

列表理解非常强大；我们还可以使用它们通过带有if子句的规则过滤掉元素，并且我们可以链接for和if子句（它的工作方式与相应的命令式代码类似，相同的子句的顺序相同；只有最终将在结果列表中结束的值才会移到前面，而不是在“最里面”部分）。如果计划是在修改副本以避免问题的同时迭代原始文件，那么通常有一种更令人愉快的方法来实现这一点，即理解过滤列表。

当我们需要按位置拒绝或插入特定元素时

假设我们有这样的东西

x = [8, 6, 7, 5, 3, 0, 9]
y = x
del y[2:-2] # oops, x was changed inappropriately

我们可以通过将我们不需要的部分放在一起来建立一个列表，而不是先创建一个单独的副本来删除我们不想要的部分。因此：

x = [8, 6, 7, 5, 3, 0, 9]
y = x[:2] + x[-2:]

通过切片处理插入、替换等操作是一项练习。只需说明您希望结果包含哪些子序列。这种情况的一个特殊情况是制作一个反向副本-假设我们需要一个新列表（而不仅仅是反向迭代），我们可以通过切片直接创建它，而不是克隆然后使用.reverse。

---

这些方法（如列表理解）还有一个优点，即它们将所需的结果创建为表达式，而不是通过程序性地就地修改现有对象（并返回None）。这对于以“流畅”风格编写代码更为方便。

使用对象[：]

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

在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

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

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 3.3+添加了list.copy（）方法，它应该和切片一样快：

newlist = old_list.copy()

在Python中，请记住：

    list1 = ['apples','bananas','pineapples']
    list2 = list1

List2没有存储实际的列表，而是对list1的引用。因此，当您对list1执行任何操作时，list2也会发生变化。使用copy模块（非默认，在pip上下载）制作列表的原始副本（对于简单列表，copy.copy（）；对于嵌套列表，copy。deepcopy（））。这将生成一个不会随第一个列表而更改的副本。