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

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

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)

我想发布一些不同于其他答案的内容。尽管这很可能不是最容易理解或最快的选项，但它提供了深度复制工作方式的一些内部视图，同时也是深度复制的另一种选择。我的函数是否有bug其实并不重要，因为这是为了展示一种复制问题答案之类的对象的方法，同时也是为了解释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]。不可变的数字不能重复，但另一层可以。您可以使用列表理解复制它：[1，2，3]中的x代表x]

现在，假设您有一个列表：[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]

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

TLDR:Depcopy使用递归来复制对象，并且只返回与以前相同的不可变对象，因为不可变对象无法复制。然而，它深度复制可变对象的最内层，直到到达对象的最外层。

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

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中克隆或复制列表有哪些选项？

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

newlist = old_list.copy()

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

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