对每种复制模式的简短解释：

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

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)

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

菲利克斯已经给出了一个很好的答案，但我想我应该对各种方法进行速度比较：

10.59秒（105.9µs/itn）-copy.depcopy（旧列表）10.16秒（101.6µs/itn）-纯Python Copy（）方法使用deepcopy复制类1.488秒（14.88µs/itn）-纯Python Copy（）方法不复制类（仅dicts/lists/tuples）0.325秒（3.25µs/itn）-对于old_list:new_list.append（项目）中的项目0.217秒（2.17µs/itn）-[i代表old_list]（列表理解）0.186秒（1.86µs/itn）-复制副本（old_list）0.075秒（0.75µs/itn）-列表（旧列表）0.053秒（0.53µs/itn）-新列表=[]；新列表扩展（旧列表）0.039秒（0.39µs/itn）-old_list[：]（列表切片）

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

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

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

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）

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