我想发布一些不同于其他答案的内容。尽管这很可能不是最容易理解或最快的选项，但它提供了深度复制工作方式的一些内部视图，同时也是深度复制的另一种选择。我的函数是否有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使用递归来复制对象，并且只返回与以前相同的不可变对象，因为不可变对象无法复制。然而，它深度复制可变对象的最内层，直到到达对象的最外层。

我想发布一些不同于其他答案的内容。尽管这很可能不是最容易理解或最快的选项，但它提供了深度复制工作方式的一些内部视图，同时也是深度复制的另一种选择。我的函数是否有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使用递归来复制对象，并且只返回与以前相同的不可变对象，因为不可变对象无法复制。然而，它深度复制可变对象的最内层，直到到达对象的最外层。

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

假设您有两个列表：

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

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

因此，首先让我们将变量副本设置为原始列表list_1：

copy = list_1

现在，如果你认为copy复制了list_1，那么你错了。id函数可以告诉我们两个变量是否可以指向同一个对象。让我们试试看：

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

输出为：

4329485320
4329485320

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

所以我们知道，Python不会在变量中存储任何内容，变量只是引用对象，对象存储值。这里的对象是一个列表，但我们通过两个不同的变量名创建了对同一对象的两个引用。这意味着两个变量都指向同一个对象，只是名称不同。

当您执行copy=list_1时，它实际上正在执行以下操作：

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

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

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

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

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

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

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

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)

有关复制中的角盒的详细信息，请参阅文档。

使用对象[：]

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

要使用的方法取决于要复制的列表的内容。如果列表中包含嵌套的dict，则deepcopy是唯一有效的方法，否则答案中列出的大多数方法（slice、loop[for]、copy、extend、combine或unpack）都将在类似的时间内工作和执行（loop和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}
]}]