我如何克隆列表，以免在分配后意外变化？

Question

在使用 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]

Answer 1

new_list = my_list 实际上并未创建第二个列表。分配仅复制对列表的引用，而不是实际列表，因此 new_list 和 my_list 在分配后请参阅同一列表。

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

• 您可以使用https://docs.python.org/library/stdtypes.html#mutable-sequence-sequence-types“ rel = “ noreferrer”> list.copy（） 方法（自Python 3.3以来可用）：

    new_list = old_list.copy（）
   

• 您可以切片：

    new_list = old_list [：]
   

  alex martelli 的观点（至少。 ;）（他认为，下一个更可读）。

  
  

• 您可以使用内置 list（） < < /a>构造函数：

    new_list = list（old_list）
   

• 您可以使用通用“ noreferrer”> copy> copy.copy.copy.copy（） ：

   导入复制
  new_list = copy.copy（old_list）
   

  这比 list（）要慢一点，因为它必须找出 old_list 首先的数据类型。

• 如果您还需要复制列表的元素，请使用通用 <代码> copy.deepcopy（） ：

   导入复制
  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}\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)]

Answer 2

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

1. 10.59 sec（105.9 µs/itn） - copy.deepcopy（old_list）
2. 10.16 sec（101.6 µs/itn） - 纯Python copy> copy> copy> copy（）>方法与DeepCopy复制类
3. 1.488秒（14.88 µs/itn） - 纯Python copy> copy（）方法不复制类（仅dicts/lists/tarples）
4. 0.325 sec（3.25 µs/itn） - >对于old_list中的项目：new_list.append（item）
5. 0.217 sec（2.17 µs/itn） - [i in old_list] （a
6. ​ /library/copy.html＃复制。
7. org ）
8. 0.053秒（0.53 µs/itn） - new_list = []; new_list.extend（old_list）
9. 0.039 sec（0.39 µs/itn） - old_list [：] （列表切片），

因此最快的是列表切片。但是请注意， copy.copy（）， list [：] 和 list（list），不同， copy> 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

Answer 3

我被告知 href =“ http://bugs.python.org/issue10516” rel =“ noreferrer”>添加 list.copy.copy（） 方法，该方法应该像切片一样快：

newlist = old_list.copy()

Answer 4

在Python中克隆或复制列表的选项是什么？

在Python 3中，可以使用：

a_copy = a_list.copy()

在Python 2和3中进行浅副本，您可以获得带有原始完整切片的浅副本：

a_copy = a_list[:]

说明

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

浅层列表复制

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

在Python 2和3中有不同的方法可以做到这一点。Python 2方法也将在Python3。Python2

中使用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.copy.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'], [], []]

该列表只是内容的一系列指针，因此浅副本仅复制指针，因此您有两个不同的列表，但是它们具有相同的内容。为了制作内容的副本，您需要深层副本。

深副本

以使a 列表的深副本，在Python 2或3中，使用 deepcopy deepcopy < /code>在复制模块中：

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

您可能会将其视为DeepCopy的一种方式，但不要这样做：

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

Answer 5

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

因此，让我们假设您有两个列表：

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

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

因此，首先让我们尝试将变量复制设置为我们的原始列表， 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']

因此，它修改了原始列表：

现在，让我们转到用于复制列表的Pythonic方法。

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 [：] 时，这发生了：

< img src =“ https://i.sstatic.net/3hpti.jpg” alt =“在此处输入图像说明”>

它创建了列表的副本，但只有外部列表副本，而不是嵌套的列表副本。两个变量的嵌套列表相同，因此，如果您尝试修改嵌套列表，则它将修改原始列表，因为两个列表的嵌套列表对象相同。

什么是解决方案？解决方案是 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']]

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

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

请参阅文档有关复制角色的更多信息。

Answer 7

使用 thing [：]

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

Answer 8

Python 3.6时间

是使用Python 3.6.8的定时结果。请记住，这些时候是相对的，而不是绝对的。

我坚持只做浅副本，还添加了一些新方法，这些方法是python＆nbsp; 2中​​不可能的，例如 list.copy.copy.copy（）（python＆nbsp; 3 slice等效）和两种形式的列表解开包装（*new_list，= list and code> new_list = [*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.copy（），尤其是考虑到后者的出色可读性。

黑马是打开包装和重新包装方法（ b = [*a] ），比原始切片快25％，速度是其他解压缩方法的两倍以上（> *b，= a ）。

b = a * 1 也表现出色。

请注意，这些方法对除列表以外的任何输入而不是输出等效结果。它们都适用于切片对象，其中一些可用于任何觉得，但只有复制.copy（）适用于更通用的Python对象。

---

这是感兴趣的各方的测试代码（ template” ）：

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)\t\t", timeit.timeit(stmt='b = list(a)', setup=setup, number=COUNT))
print("b = copy.copy(a)\t", timeit.timeit(stmt='b = copy.copy(a)', setup=setup, number=COUNT))
print("b = a.copy()\t\t", timeit.timeit(stmt='b = a.copy()', setup=setup, number=COUNT))
print("b = a[:]\t\t", timeit.timeit(stmt='b = a[:]', setup=setup, number=COUNT))
print("b = a[0:len(a)]\t\t", timeit.timeit(stmt='b = a[0:len(a)]', setup=setup, number=COUNT))
print("*b, = a\t\t\t", timeit.timeit(stmt='*b, = a', setup=setup, number=COUNT))
print("b = []; b.extend(a)\t", timeit.timeit(stmt='b = []; b.extend(a)', setup=setup, number=COUNT))
print("b = []; for item in a: b.append(item)\t", timeit.timeit(stmt='b = []\nfor item in a:  b.append(item)', setup=setup, number=COUNT))
print("b = [i for i in a]\t", timeit.timeit(stmt='b = [i for i in a]', setup=setup, number=COUNT))
print("b = [*a]\t\t", timeit.timeit(stmt='b = [*a]', setup=setup, number=COUNT))
print("b = a * 1\t\t", timeit.timeit(stmt='b = a * 1', setup=setup, number=COUNT))

Answer 9

python的习语是 newlist = oldlist [：]

Answer 10

所有其他贡献者都给出了出色答案，当您具有单个维度（级别）列表时，这些答案可起作用，但是到目前为止提到的方法，只有 copy.deepcopy（）当您使用多维的嵌套列表（列表列表）时，可以用克隆/复制列表，而没有指向嵌套的 list 对象。而 felix kling 在他的答案中指的是它，问题还有更多，可能还有一个解决工具的方法内置可能证明是 deepcopy 的更快替代方案。

new_list = old_list [：] ， copy.copy（old_list）'和py3k old_list.copy.copy（）为单层列表工作，他们还原为指向 list 嵌套在 old_list 和 new_list 中的对象，并更改为 list 对象在另一个中存在。

编辑：揭露新信息

正如两个 aaron Hall 和 pm 2ring 使用 eval（）不仅是一个坏主意，而且比 copy.deepcopy（ ）。

这意味着对于多维列表，唯一的选项是 copy.deepcopy（）。话虽如此，这确实不是一个选择，因为当您尝试在适度尺寸的多维阵列上使用时，性能就向南行驶。我尝试使用42x42数组来 timeit ，而不是闻所未闻的，甚至不是那么大的生物信息信息应用程序，我放弃了等待响应，刚刚开始将我的编辑键入此帖子。

>

似乎唯一真正的选择是初始化多个列表并独立处理它们。如果有人对如何处理多维列表复制，这将不胜感激。

。

正如其他人所说的那样， 使用复制模块和 copy.deepcopy 绩效问题强>用于多维列表 。

Answer 11

令我惊讶的是，尚未提及这一点，因此为了完整的目的，

您可以执行用“ Splat Operator”打开包装的列表：*，它也将复制列表的元素。

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)

Answer 12

new_list = my_list[:]

new_list = my_list

尝试理解这一点。假设 my_list 位于位置x，即， my_list 的位置。 '让 new_list 指向X。这被称为a 浅复制。

现在，如果您将 new_list = my_list [：] 分配，您只是将每个对象复制到 my_list new_list 。这被称为A 深拷贝。

您可以做到的其他方法是：

•   new_list = list（old_list）
   

•  导入复制
  new_list = copy.deepcopy（old_list）
   

Answer 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当我们不使用嵌套列表时。让我们检查一下当我们将解决方案＃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

Answer 14

我想发布一些与其他答案有所不同的内容。即使这很可能不是最容易理解或最快的选择，但它提供了一些内部视图，可以很好地了解深拷贝的工作原理，并且是深层复制的另一种选择。我的功能是否有错误并不重要，因为这样做的目的是显示出一种复制诸如“问题答案”之类的对象的方法，同时也将其作为解释DeepCopy在其核心方面的工作方式。

任何深层复制功能的核心都是制作浅副本的方法。如何？简单的。任何深层复制功能都只能复制不变对象的容器。当您深入嵌套列表时，您只会复制外部列表，而不是列表内部的可变对象。您仅重复容器。上课也相同的作品。当您深入一堂课时，您会深入副本所有可变属性。那怎么？您只需要复制列表，dict，元组，迭代，课程和课堂实例之类的容器？

很简单。一个可变的对象并不能真正重复。它永远无法更改，因此它只是一个值。这意味着您永远不必复制字符串，数字，布尔或任何一个。但是，您将如何复制容器？简单的。您只需初始化一个具有所有值的新容器。深拷贝依赖于递归。它复制了所有容器，甚至在其中包含容器，直到没有容器。容器是一个不变的对象。

一旦您知道这一点，就可以完全复制一个没有任何参考的对象。这是用于深编辑基本数据类型的功能（对自定义类不起作用，但您可以始终添加）

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依靠该示例。唯一的区别是它支持其他类型，并且还通过将属性复制到新的重复类中来支持用户级，并以对对象的参考来阻止Infinite recursion，它已经使用备忘录列表或词典看到了它。这确实是为了制作深层副本。从本质上讲，制作深层副本只是制作浅副本。我希望这个答案为问题增加了一些东西。

示例

说您有此列表： [1，2，3] 。不变的数字不能重复，但另一层可以。您可以使用列表理解来复制它： [x for x in [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]

然后，您拥有一个函数，可以deepCopy strs，bools，bools，ploast，ints的任何列表甚至列表使用递归无限多层。在那里，您有它，深层复制。

tldr ：DeepCopy使用递归来复制对象，并且仅返回与以前相同的不变对象，因为不可变的对象无法重复。但是，它深深地构成了可变物体的最内部层，直到到达对象的最外面可变层为止。

Answer 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

Answer 16

请记住，在Python中，当您使用时：

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

List2不是存储实际列表，而是对List1的引用。因此，当您对List1做任何事情时，List2也会更改。使用复制模块（不默认，在PIP上下载）来制作列表的原始副本（ copy.copy（） for简单列表， copy.deepcopy（） for嵌套）。这制作了一个不会随第一个列表而变化的副本。

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

Answer 18

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

我用python 3.8进行了测试：

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

这不是最好的答案，但它起作用。

Answer 19

这是因为，行 new_list = my_list 为变量 my_list 分配新的引用
这类似于下面给出的 c 代码，

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

您应该使用复制模块来创建一个新列表

import copy
new_list = copy.deepcopy(my_list)

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

Answer 21

使用的方法取决于要复制列表的内容。如果该列表包含嵌套 dicts 而不是deepcopy是唯一有效的方法，否则答案中列出的大多数方法（slice，loop [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}
]}]

Answer 22

要了解不同的python克隆/复制选项，请查看此代码，该代码“复制”了嵌套列表的三种不同的方式，并使用 memory_graph 要绘制结果：

import memory_graph as mg # see link above for install instructions
import copy

a = [ [1, 2], ['x', 'y'] ] # a nested list (a list containing other lists)

# three different ways to make a "copy" of 'a':
c1 = a
c2 = copy.copy(a) # equivalent to:  a.copy() a[:] list(a)
c3 = copy.deepcopy(a)

mg.show(locals()) # show the graph

• c1 是 sigsment ，没有复制，所有值共享
• c2 is A 浅副本，仅复制第一个参考的值，所有基础值共享
• c3 is a 深拷贝，所有值复制，什么都没有共享
  

全面披露：我是 memory_graph 。

Answer 23

框架挑战：您是否需要复制应用程序？

我经常看到试图以某种迭代方式修改列表副本的代码。要构建一个微不足道的示例，假设我们有不工作（因为 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 ，而不是同一列表的名称，因此循环的将做正确的事情。

但这是错误的方法。从功能上讲，我们真正想要做的是制作新列表，它是基于的原始> 。

我们不需要先制作副本就可以做到这一点，而且通常不应该这样做。

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

，自然工具的自然工具就是列表的理解。这样，我们写下逻辑，告诉我们所需结果中的元素如何与原始元素相关。简单，优雅和富有表现力；而且，我们避免需要解决方法以修改 y 在 loop中复制复制（因为分配给迭代变量不会影响列表 - ，其原因是我们首先希望副本！）。

在上面的示例中，它看起来像：

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

列表综合功能非常强大；我们还可以使用它们来通过规则过滤元素，并使用子句子句，并且我们可以为 and and 链条（如果> renauses）（它的工作方式）相同的条款以相同的顺序 的相应代码;如果计划在修改副本“>避免问题）的情况下进行修改通过过滤列表的理解。

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

假设我们有类似的东西，而

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

不是首先制作 y 首先删除我们不想要的零件，我们可以构建一个列表通过将我们 do 的零件放在一起。因此：

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

通过切片处理插入，替换等。恰恰理解您希望结果包含哪些子序列。这样的一种特殊情况是进行反向副本 - 假设我们完全需要一个新列表（而不是仅仅是<倒向），我们可以直接通过切割而不是克隆，然后使用 reververs 来直接创建它。

---

这些方法（例如列表理解）也具有将所需结果创建为表达式的优势，而不是通过程序将现有对象定为就地（和

Answer 24

每个副本模式的简短说明：

a 浅副本构造一个新的复合对象，然后（在可能的程度上）将引用插入到原始中的对象中 - 创建浅副本

new_list = my_list

： 深层复制构建一个新的复合对象，然后递归地将副本插入原始的对象中 - 创建一个深拷贝：

new_list = list(my_list)

list（）在深处工作正常简单列表的副本，例如：

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

但是，对于

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

...

import copy
new_complex_list = copy.deepcopy(my_complex_list)

Answer 25

new_list = my_list

因为： new_list 将仅是对 my_list 的参考，而在 new_list 中进行的更改也将在 my_list 反之亦然，

有两种复制列表

new_list = my_list.copy()

或

new_list = list(my_list)