问题描述：

使用时new_list = my_list，每次对 的任何修改都会new_list发生变化my_list。为什么会这样？我该如何克隆或复制列表以防止这种情况发生？例如：

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

解决方案 1：

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

要实际复制列表，您有以下几种选择：

• 您可以使用内置list.copy()方法（自 Python 3.3 起可用）：

new_list = old_list.copy()

• 你可以切片：

new_list = old_list[:]

Alex Martelli对此的看法（至少在 2007 年）是，这是一种奇怪的语法，并且永远没有意义使用它。;）（在他看来，下一个更具可读性）。

• 您可以使用内置构造函数list()：

new_list = list(old_list)

• 您可以使用泛型copy.copy()：

import copy
new_list = copy.copy(old_list)

这比它慢一点list()，因为它必须先找出数据类型old_list。

• 如果您还需要复制列表的元素，请使用泛型copy.deepcopy()：

import copy
new_list = copy.deepcopy(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}
list.copy(): {b}
slice: {c}
list(): {d}
copy: {e}
deepcopy: {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)]

解决方案 2：

Felix 已经提供了一个很好的答案，但我想对各种方法进行速度比较：

1. 10.59 秒（105.9 微秒/itn） - copy.deepcopy(old_list)

2. 10.16 秒 (101.6 µs/itn) - 纯 PythonCopy()方法使用 deepcopy 复制类

3. 1.488 秒 (14.88 µs/itn) - 纯 PythonCopy()方法不复制类 (仅字典/列表/元组)

4. 0.325 秒 (3.25 µs/itn) -for item in old_list: new_list.append(item)

5. 0.217 秒 (2.17 µs/itn) - [i for i in old_list](列表推导式)

6. 0.186 秒 (1.86 µs/itn) -copy.copy(old_list)

7. 0.075 秒 (0.75 µs/itn) -list(old_list)

8. 0.053 秒（0.53 微秒/itn） -new_list = []; new_list.extend(old_list)

9. 0.039 秒 (0.39 µs/itn) - old_list[:](列表切片)

因此最快的是列表切片。但请注意copy.copy()，list[:]与list(list)不同copy.deepcopy()，python 版本不会复制列表中的任何列表、字典和类实例，因此如果原始内容发生变化，它们也会在复制的列表中发生变化，反之亦然。

（如果有人感兴趣或者想提出任何问题，这里是脚本：）

from copy import deepcopy

class old_class:
    def __init__(self):
        self.blah = 'blah'

class new_class(object):
    def __init__(self):
        self.blah = 'blah'

dignore = {str: None, unicode: None, int: None, type(None): None}

def Copy(obj, use_deepcopy=True):
    t = type(obj)

    if t in (list, tuple):
        if t == tuple:
            # Convert to a list if a tuple to
            # allow assigning to when copying
            is_tuple = True
            obj = list(obj)
        else:
            # Otherwise just do a quick slice copy
            obj = obj[:]
            is_tuple = False

        # Copy each item recursively
        for x in xrange(len(obj)):
            if type(obj[x]) in dignore:
                continue
            obj[x] = Copy(obj[x], use_deepcopy)

        if is_tuple:
            # Convert back into a tuple again
            obj = tuple(obj)

    elif t == dict:
        # Use the fast shallow dict copy() method and copy any
        # values which aren't immutable (like lists, dicts etc)
        obj = obj.copy()
        for k in obj:
            if type(obj[k]) in dignore:
                continue
            obj[k] = Copy(obj[k], use_deepcopy)

    elif t in dignore:
        # Numeric or string/unicode?
        # It's immutable, so ignore it!
        pass

    elif use_deepcopy:
        obj = deepcopy(obj)
    return obj

if __name__ == '__main__':
    import copy
    from time import time

    num_times = 100000
    L = [None, 'blah', 1, 543.4532,
         ['foo'], ('bar',), {'blah': 'blah'},
         old_class(), new_class()]

    t = time()
    for i in xrange(num_times):
        Copy(L)
    print 'Custom Copy:', time()-t

    t = time()
    for i in xrange(num_times):
        Copy(L, use_deepcopy=False)
    print 'Custom Copy Only Copying Lists/Tuples/Dicts (no classes):', time()-t

    t = time()
    for i in xrange(num_times):
        copy.copy(L)
    print 'copy.copy:', time()-t

    t = time()
    for i in xrange(num_times):
        copy.deepcopy(L)
    print 'copy.deepcopy:', time()-t

    t = time()
    for i in xrange(num_times):
        L[:]
    print 'list slicing [:]:', time()-t

    t = time()
    for i in xrange(num_times):
        list(L)
    print 'list(L):', time()-t

    t = time()
    for i in xrange(num_times):
        [i for i in L]
    print 'list expression(L):', time()-t

    t = time()
    for i in xrange(num_times):
        a = []
        a.extend(L)
    print 'list extend:', time()-t

    t = time()
    for i in xrange(num_times):
        a = []
        for y in L:
            a.append(y)
    print 'list append:', time()-t

    t = time()
    for i in xrange(num_times):
        a = []
        a.extend(i for i in L)
    print 'generator expression extend:', time()-t

解决方案 3：

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

newlist = old_list.copy()

解决方案 4：

在 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。这是为什么呢？

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

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

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

深层复制

要对列表进行深层复制，在 Python 2 或 3 中，在模块deepcopy中copy使用：

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))

1. 这是很危险的，特别是当你评估来自不信任来源的事物时。

2. 如果您复制的子元素没有可以通过评估来重现等效元素的表示形式，那么它是不可靠的。

3. 它的性能也较差。

在 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

解决方案 5：

让我们从头开始探索这个问题。

假设您有两个列表：

list_1 = ['01', '98']
list_2 = [['01', '98']]

我们必须复制这两个列表，现在从第一个列表开始：

因此首先让我们尝试将变量设置copy为我们的原始列表list_1：

copy = list_1

现在，如果你认为复制了 list_1 ，那你就错了。该id函数可以向我们展示两个变量是否可以指向同一个对象。让我们试试这个：

print(id(copy))
print(id(list_1))

输出为：

4329485320
4329485320

两个变量都是完全相同的参数。你感到惊讶吗？

我们知道，Python 不会在变量中存储任何东西，变量只是引用对象，对象存储值。这里对象是一个，list但我们用两个不同的变量名创建了对同一对象的两个引用。这意味着两个变量都指向同一个对象，只是名称不同。

当你这样做时copy = list_1，它实际上是在做：

这里的图像list_1和copy是两个变量名，但两个变量的对象是相同的list。

因此，如果您尝试修改复制的列表，那么它也会修改原始列表，因为该列表只有一个，无论您是从复制的列表还是从原始列表进行修改，您都会修改该列表：

copy[0] = "modify"

print(copy)
print(list_1)

输出：

['modify', '98']
['modify', '98']

因此对原列表进行了修改：

现在让我们讨论一下复制列表的 Python 方法。

copy_1 = list_1[:]

此方法解决了我们遇到的第一个问题：

print(id(copy_1))
print(id(list_1))

4338792136
4338791432

我们看到两个列表都有不同的 id，这意味着两个变量都指向不同的对象。所以这里实际发生的事情是：

现在让我们尝试修改列表，看看是否仍然面临前面的问题：

copy_1[0] = "modify"

print(list_1)
print(copy_1)

输出为：

['01', '98']
['modify', '98']

如您所见，它仅修改了复制的列表。这意味着它起作用了。

你觉得我们完成了吗？不。让我们尝试复制嵌套列表。

copy_2 = list_2[:]

list_2应该引用另一个对象，它是 的副本list_2。让我们检查一下：

print(id((list_2)), id(copy_2))

我们得到输出：

4330403592 4330403528

现在我们可以假设两个列表都指向不同的对象，所以现在让我们尝试修改它并看看它是否给出了我们想要的内容：

copy_2[0][1] = "modify"

print(list_2, copy_2)

这给了我们输出：

[['01', 'modify']] [['01', 'modify']]

这看起来可能有点令人困惑，因为我们之前使用的方法也有效。让我们试着理解一下。

当你这样做时：

copy_2 = list_2[:]

您仅复制了外部列表，而不是内部列表。我们可以id再次使用该函数来检查这一点。

print(id(copy_2[0]))
print(id(list_2[0]))

输出为：

4329485832
4329485832

当我们这样做时copy_2 = list_2[:]，会发生以下情况：

它创建列表的副本，但仅创建外部列表副本，而不是嵌套列表副本。嵌套列表对于两个变量都是相同的，因此如果您尝试修改嵌套列表，那么它也会修改原始列表，因为嵌套列表对象对于两个列表都是相同的。

解决方案是什么？解决方案就是函数deepcopy。

from copy import deepcopy
deep = deepcopy(list_2)

我们来检查一下：

print(id((list_2)), id(deep))

4322146056 4322148040

两个外部列表都有不同的 ID。让我们在内部嵌套列表中尝试一下。

print(id(deep[0]))
print(id(list_2[0]))

输出为：

4322145992
4322145800

如您所见，两个 ID 不同，这意味着我们可以假设两个嵌套列表现在指向不同的对象。

这意味着当你这样做时deep = deepcopy(list_2)实际上会发生以下事情：

两个嵌套列表都指向不同的对象，并且它们现在具有嵌套列表的单独副本。

现在让我们尝试修改嵌套列表，看看它是否解决了前面的问题：

deep[0][1] = "modify"
print(list_2, deep)

它输出：

[['01', '98']] [['01', 'modify']]

如您所见，它没有修改原始嵌套列表，它只修改了复制的列表。

解决方案 6：

已经有许多答案告诉您如何进行正确的复制，但没有一个答案说明为什么您的原始“复制”失败了。

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)

有关复制中的特殊情况的更多信息，请参阅文档。

解决方案 7：

使用thing[:]

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

解决方案 8：

Python 3.6 时间

以下是使用 Python 3.6.8 的计时结果。请记住，这些时间是相对的，而不是绝对的。

我坚持只做浅拷贝，并且添加了一些 Python 2 中不可能实现的新方法，比如（相当于list.copy()Python 3的切片）和两种列表解包形式（和）：*new_list, = list`new_list = [*list]`

METHOD                TIME TAKEN
b = [*a]               2.75180600000021
b = a * 1              3.50215399999990
b = a[:]               3.78278899999986  # Python 2 winner (see above)
b = a.copy()           4.20556500000020  # Python 3 "slice equivalent" (see above)
b = []; b.extend(a)    4.68069800000012
b = a[0:len(a)]        6.84498999999959
*b, = a                7.54031799999984
b = list(a)            7.75815899999997
b = [i for i in a]    18.4886440000000
b = copy.copy(a)      18.8254879999999
b = []
for item in a:
  b.append(item)      35.4729199999997

我们可以看到 Python 2 的获胜者仍然表现良好，但并没有比 Python 3 领先list.copy()太多，尤其是考虑到后者更出色的可读性。

黑马是拆包和重新打包方法 ( b = [*a])，它比原始切片快约 25%，比其他拆包方法快两倍多 ( *b, = a)。

b = a * 1也表现得出奇的好。

请注意，这些方法不会对列表以外的任何输入输出等效结果。它们都适用于可切片对象，一些适用于任何可迭代对象，但仅copy.copy()适用于更通用的 Python 对象。

以下是供相关方测试的代码（模板来自这里）：

import timeit

COUNT = 50000000
print("Array duplicating. Tests run", COUNT, "times")
setup = 'a = [0,1,2,3,4,5,6,7,8,9]; import copy'

print("b = list(a)        ", timeit.timeit(stmt='b = list(a)', setup=setup, number=COUNT))
print("b = copy.copy(a)    ", timeit.timeit(stmt='b = copy.copy(a)', setup=setup, number=COUNT))
print("b = a.copy()        ", timeit.timeit(stmt='b = a.copy()', setup=setup, number=COUNT))
print("b = a[:]        ", timeit.timeit(stmt='b = a[:]', setup=setup, number=COUNT))
print("b = a[0:len(a)]        ", timeit.timeit(stmt='b = a[0:len(a)]', setup=setup, number=COUNT))
print("*b, = a            ", timeit.timeit(stmt='*b, = a', setup=setup, number=COUNT))
print("b = []; b.extend(a)    ", timeit.timeit(stmt='b = []; b.extend(a)', setup=setup, number=COUNT))
print("b = []; for item in a: b.append(item)    ", timeit.timeit(stmt='b = []
for item in a:  b.append(item)', setup=setup, number=COUNT))
print("b = [i for i in a]    ", timeit.timeit(stmt='b = [i for i in a]', setup=setup, number=COUNT))
print("b = [*a]        ", timeit.timeit(stmt='b = [*a]', setup=setup, number=COUNT))
print("b = a * 1        ", timeit.timeit(stmt='b = a * 1', setup=setup, number=COUNT))

解决方案 9：

Python 中实现这个功能的惯用方法是newList = oldList[:]

解决方案 10：

所有其他贡献者都给出了很好的答案，这些答案在您拥有单维（分级）列表时有效，但是到目前为止提到的方法，在您使用多维嵌套列表（列表的列表）时，copy.deepcopy()只能克隆/复制列表，而不能使其指向嵌套对象。虽然Felix Kling在他的回答中提到了这一点，但这个问题还有更多内容，可能还有一种使用内置函数的解决方法，这可能是更快的替代方案。list`deepcopy`

虽然Py3k 的 和 适用new_list = old_list[:]于单级列表，但它们会恢复为指向嵌套在和内的对象，并且对其中一个对象的更改会在另一个对象中延续。copy.copy(old_list)'`old_list.copy()listold_listnew_listlist`

编辑：新信息曝光

正如Aaron Hall和PM 2Ring 所指出的那样，使用eval()不仅是个坏主意，而且比 慢得多copy.deepcopy()。

这意味着对于多维列表，唯一的选择是copy.deepcopy()。话虽如此，但这实际上不是一个选择，因为当您尝试在中等大小的多维数组上使用它时，性能会大大下降。我尝试使用timeit42x42 数组，对于生物信息学应用来说，这并不罕见，甚至这么大，我放弃了等待回复，开始对这篇文章进行编辑。

看来唯一真正的选择是初始化多个列表并独立处理它们。如果有人对如何处理多维列表复制有任何其他建议，我将不胜感激。

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

解决方案 11：

令我惊讶的是，这一点还没有被提及，所以为了完整性......

您可以使用“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)

解决方案 12：

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。这称为深层复制。

您还可以使用其他方法来执行此操作：

* ```
import copy
new_list = copy.deepcopy(old_list)

解决方案 13：

在已经给出的答案中缺少一种独立于 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

.奖励：如果你不想复制元素，请使用（又称浅拷贝）：

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

解决方案 14：

我想发布一些与其他答案略有不同的内容。尽管这很可能不是最容易理解或最快的选项，但它提供了一些关于深度复制工作原理的内部视图，并且是深度复制的另一种替代选项。我的函数是否有错误并不重要，因为这样做的目的是展示一种复制对象的方法，例如问题答案，同时也以此为重点来解释深度复制的核心工作原理。

任何深层复制函数的核心都是进行浅层复制的方法。怎么做？很简单。任何深层复制函数都只复制不可变对象的容器。当你深度复制嵌套列表时，你只会复制外部列表，而不会复制列表内的可变对象。你只是复制了容器。类也是如此。当你深度复制一个类时，你会深度复制它的所有可变属性。那么，怎么做呢？为什么你只需要复制容器，比如列表、字典、元组、迭代器、类和类实例？

很简单。可变对象实际上无法复制。它永远无法改变，因此它只是一个值。这意味着您永远不必复制字符串、数字、布尔值或其中任何一个。但是您将如何复制容器？很简单。您只需用所有值初始化一个新容器。Deepcopy 依赖于递归。它会复制所有容器，甚至复制其中有容器的容器，直到没有剩余容器。容器是不可变的对象。

一旦你知道了这一点，完全复制一个没有任何引用的对象就很容易了。这是一个用于深度复制基本数据类型的函数（不适用于自定义类，但你总是可以添加它）

def deepcopy(x):
  immutables = (str, int, bool, float)
  mutables = (list, dict, tuple)
  if isinstance(x, immutables):
    return x
  elif isinstance(x, mutables):
    if isinstance(x, tuple):
      return tuple(deepcopy(list(x)))
    elif isinstance(x, list):
      return [deepcopy(y) for y in x]
    elif isinstance(x, dict):
      values = [deepcopy(y) for y in list(x.values())]
      keys = list(x.keys())
      return dict(zip(keys, values))

Python 自己的内置 deepcopy 就是基于该示例的。唯一的区别是它支持其他类型，并且还通过将属性复制到新的重复类中来支持用户类，并且还使用备忘录列表或字典通过引用已经看到的对象来阻止无限递归。这就是制作深层副本的真正目的。从本质上讲，制作深层副本只是制作浅层副本。我希望这个答案可以为这个问题增添一些内容。

示例

假设您有此列表：[1, 2, 3]。不可变数字不能复制，但另一层可以。您可以使用列表推导来复制它：[x for x in [1, 2, 3]]

现在，假设您有这个列表：[[1, 2], [3, 4], [5, 6]]。这次，您想要创建一个函数，它使用递归来深度复制列表的所有层。而不是之前的列表理解：

[x for x in _list]

它对列表使用了一个新的：

[deepcopy_list(x) for x in _list]

deepcopy_list如下所示：

def deepcopy_list(x):
  if isinstance(x, (str, bool, float, int)):
    return x
  else:
    return [deepcopy_list(y) for y in x]

现在您有了一个函数，可以使用递归将任何strs、bool、floast、int甚至列表的列表深度复制到无限多个层。这就是深度复制。

TLDR：Deepcopy 使用递归来复制对象，并且仅返回与之前相同的不可变对象，因为不可变对象无法复制。但是，它会深度复制可变对象的最内层，直到到达对象的最外层可变层。

解决方案 15：

请注意，在某些情况下，如果您已经定义了自己的自定义类并且想要保留属性，那么您应该使用copy.copy()或copy.deepcopy()而不是替代方法，例如在 Python 3 中：

import copy

class MyList(list):
    pass

lst = MyList([1,2,3])

lst.name = 'custom list'

d = {
'original': lst,
'slicecopy' : lst[:],
'lstcopy' : lst.copy(),
'copycopy': copy.copy(lst),
'deepcopy': copy.deepcopy(lst)
}


for k,v in d.items():
    print('lst: {}'.format(k), end=', ')
    try:
        name = v.name
    except AttributeError:
        name = 'NA'
    print('name: {}'.format(name))

输出：

lst: original, name: custom list
lst: slicecopy, name: NA
lst: lstcopy, name: NA
lst: copycopy, name: custom list
lst: deepcopy, name: custom list

解决方案 16：

请记住，在 Python 中执行以下操作时：

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

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

解决方案 17：

通过 id 和 gc 来查看内存的一个稍微实用的视角。

>>> b = a = ['hell', 'word']
>>> c = ['hell', 'word']

>>> id(a), id(b), id(c)
(4424020872, 4424020872, 4423979272) 
     |           |
      -----------

>>> id(a[0]), id(b[0]), id(c[0])
(4424018328, 4424018328, 4424018328) # all referring to same 'hell'
     |           |           |
      -----------------------

>>> id(a[0][0]), id(b[0][0]), id(c[0][0])
(4422785208, 4422785208, 4422785208) # all referring to same 'h'
     |           |           |
      -----------------------

>>> a[0] += 'o'
>>> a,b,c
(['hello', 'word'], ['hello', 'word'], ['hell', 'word'])  # b changed too
>>> id(a[0]), id(b[0]), id(c[0])
(4424018384, 4424018384, 4424018328) # augmented assignment changed a[0],b[0]
     |           |
      -----------

>>> b = a = ['hell', 'word']
>>> id(a[0]), id(b[0]), id(c[0])
(4424018328, 4424018328, 4424018328) # the same hell
     |           |           |
      -----------------------

>>> import gc
>>> gc.get_referrers(a[0]) 
[['hell', 'word'], ['hell', 'word']]  # one copy belong to a,b, the another for c
>>> gc.get_referrers(('hell'))
[['hell', 'word'], ['hell', 'word'], ('hell', None)] # ('hello', None) 

解决方案 18：

还有另一种复制迄今为止未列出的列表的方法：添加一个空列表：l2 = l + []。

我使用 Python 3.8 进行了测试：

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

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

解决方案 19：

这是因为，该行new_list = my_list给变量分配了一个新的引用my_list，new_list
这与下面给出的代码类似C，

int my_list[] = [1,2,3,4];
int *new_list;
new_list = my_list;

您应该使用复制模块通过以下方式创建新列表

import copy
new_list = copy.deepcopy(my_list)

解决方案 20：

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

解决方案 21：

使用的方法取决于要复制的列表的内容。如果列表包含嵌套，dicts则 deepcopy 是唯一有效的方法，否则答案中列出的大多数方法（切片、循环 [for]、复制、扩展、合并或解包）都将有效并在相似的时间内执行（循环和 deepcopy 除外，它们的表现最差）。

脚本

from random import randint
from time import time
import copy

item_count = 100000

def copy_type(l1: list, l2: list):
  if l1 == l2:
    return 'shallow'
  return 'deep'

def run_time(start, end):
  run = end - start
  return int(run * 1000000)

def list_combine(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = [] + l1
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'combine', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_extend(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = []
  l2.extend(l1)
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'extend', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_unpack(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = [*l1]
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'unpack', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_deepcopy(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = copy.deepcopy(l1)
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'deepcopy', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_copy(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = list.copy(l1)
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'copy', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_slice(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = l1[:]
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'slice', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_loop(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = []
  for i in range(len(l1)):
    l2.append(l1[i])
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'loop', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

def list_list(data):
  l1 = [data for i in range(item_count)]
  start = time()
  l2 = list(l1)
  end = time()
  if type(data) == dict:
    l2[0]['test'].append(1)
  elif type(data) == list:
    l2.append(1)
  return {'method': 'list()', 'copy_type': copy_type(l1, l2), 
          'time_µs': run_time(start, end)}

if __name__ == '__main__':
  list_type = [{'list[dict]': {'test': [1, 1]}}, 
          {'list[list]': [1, 1]}]
  store = []
  for data in list_type:
    key = list(data.keys())[0]
    store.append({key: [list_unpack(data[key]), list_extend(data[key]), 
                list_combine(data[key]), list_deepcopy(data[key]), 
                list_copy(data[key]), list_slice(data[key]),           
                list_loop(data[key])]})
  print(store)

结果

[{"list[dict]": [
  {"method": "unpack", "copy_type": "shallow", "time_µs": 56149},
  {"method": "extend", "copy_type": "shallow", "time_µs": 52991},
  {"method": "combine", "copy_type": "shallow", "time_µs": 53726},
  {"method": "deepcopy", "copy_type": "deep", "time_µs": 2702616},
  {"method": "copy", "copy_type": "shallow", "time_µs": 52204},
  {"method": "slice", "copy_type": "shallow", "time_µs": 52223},
  {"method": "loop", "copy_type": "shallow", "time_µs": 836928}]},
{"list[list]": [
  {"method": "unpack", "copy_type": "deep", "time_µs": 52313},
  {"method": "extend", "copy_type": "deep", "time_µs": 52550},
  {"method": "combine", "copy_type": "deep", "time_µs": 53203},
  {"method": "deepcopy", "copy_type": "deep", "time_µs": 2608560},
  {"method": "copy", "copy_type": "deep", "time_µs": 53210},
  {"method": "slice", "copy_type": "deep", "time_µs": 52937},
  {"method": "loop", "copy_type": "deep", "time_µs": 834774}
]}]

解决方案 22：

框架挑战：您的应用程序真的需要复制吗？

我经常看到一些代码试图以某种迭代方式修改列表的副本。为了构造一个简单的示例，假设我们有以下不起作用的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能够做正确的事情。

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

我们不需要先复制一份来执行此操作，而且通常也不应该这样做。

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

实现这一点的自然工具是列表推导。这样，我们编写的逻辑告诉我们所需结果中的元素与原始元素之间的关系。它简单、优雅且富有表现力；并且我们避免了在循环中修改副本的变通方法y（for因为分配给迭代变量不会影响列表-原因与我们最初想要副本的原因相同！）。

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

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

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

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

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

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

解决方案 23：

每种复印模式的简短解释：

浅拷贝构造一个新的复合对象，然后（在可能的范围内）将对原始对象的引用插入到其中 - 创建浅拷贝：

new_list = my_list

深层复制构造一个新的复合对象，然后以递归方式将原始对象的副本插入其中 - 创建深层复制：

new_list = list(my_list)

list()适用于简单列表的深度复制，例如：

my_list = ["A","B","C"]

但是，对于像这样的复杂列表......

my_complex_list = [{'A' : 500, 'B' : 501},{'C' : 502}]

...使用deepcopy()：

import copy
new_complex_list = copy.deepcopy(my_complex_list)

解决方案 24：

new_list = my_list

因为：new_list只是对my_list 的引用，在new_list中所做的更改也会自动在my_list中进行，反之亦然

有两种简单的方法可以复制列表

new_list = my_list.copy()

或者

new_list = list(my_list)