Question

我想在python中制作dict的深层副本。遗憾的是，.deepcopy()不存在dict方法。我该怎么做？

>>> my_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}
>>> my_copy = my_dict.deepcopy()
Traceback (most recent calll last):
  File "<stdin>", line 1, in <module>
AttributeError: 'dict' object has no attribute 'deepcopy'
>>> my_copy = my_dict.copy()
>>> my_dict['a'][2] = 7
>>> my_copy['a'][2]
7

最后一行应为3。

我希望my_dict中的修改不会影响快照my_copy。

我该怎么做？该解决方案应与Python 3.x兼容。

Answer 1

怎么样：

import copy
d = { ... }
d2 = copy.deepcopy(d)

Python 2或3：

Python 3.2 (r32:88445, Feb 20 2011, 21:30:00) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import copy
>>> my_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}
>>> my_copy = copy.deepcopy(my_dict)
>>> my_dict['a'][2] = 7
>>> my_copy['a'][2]
3
>>>

Answer 2

dict.copy（） 是字典的浅拷贝函数
id 是内置函数，可为您提供变量的地址

首先，您需要了解“为什么会出现这个特殊问题？”

In [1]: my_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}

In [2]: my_copy = my_dict.copy()

In [3]: id(my_dict)
Out[3]: 140190444167808

In [4]: id(my_copy)
Out[4]: 140190444170328

In [5]: id(my_copy['a'])
Out[5]: 140190444024104

In [6]: id(my_dict['a'])
Out[6]: 140190444024104

键'a'的两个词组中出现的列表的地址指向相同的位置。
因此，当您更改my_dict中列表的值时，my_copy中的列表也会更改。

<强>解决方案：

In [7]: my_copy = {key: value[:] for key, value in my_dict.items()}

In [8]: id(my_copy['a'])
Out[8]: 140190444024176

或者你可以使用上面提到的深度复制。

Answer 3

Python 3.x

来自复制导入深度复制的

my_dict = {'one': 1, 'two': 2}
new_dict_deepcopy = deepcopy(my_dict)

如果没有深度复制，我无法从域字典中删除主机名字典。

如果没有深度检查，我会收到以下错误：

"RuntimeError: dictionary changed size during iteration"

...当我尝试从另一个字典里面的字典中删除所需的元素时。

import socket
import xml.etree.ElementTree as ET
from copy import deepcopy

domain是一个字典对象

def remove_hostname(domain, hostname):
    domain_copy = deepcopy(domain)
    for domains, hosts in domain_copy.items():
        for host, port in hosts.items():
           if host == hostname:
                del domain[domains][host]
    return domain

示例输出： [orginal] domains = {'localdomain'：{'localhost'：{'all'：'4000'}}}

[new] domains = {'localdomain'：{}}}

所以这里发生的事情是我在迭代字典的副本而不是遍历字典本身。使用此方法，您可以根据需要删除元素。

Answer 4

我今天刚刚学习 Python（3.7.7 作为 REPL 接口软件环境的表达式评估器部分），我发现有一个 frozenset 可能对此有用。我在这个答案中了解到它： https://stackoverflow.com/a/11251781/832705

一些文档应该在这里： https://docs.python.org/3/library/stdtypes.html?highlight=frozenset#frozenset

我的想法是，frozenset 应该像一个足够深的副本，用于列表/字典类型对象的迭代，该对象在迭代过程中倾向于抛出“RuntimeError：dictionary changed size during iteration”错误。

我的意思是稍后再回来学习frozenset。如果你对这个答案投反对票，因为它是错误的、不适用的，或者出于其他原因，至少会提醒我多学习。

Answer 5

我喜欢Lasse V. Karlsen并从中学到了很多东西。我将其修改为以下示例，该示例很好地突出了浅字典副本和深副本之间的区别：

    import copy

    my_dict = {'a': [1, 2, 3], 'b': [4, 5, 6]}
    my_copy = copy.copy(my_dict)
    my_deepcopy = copy.deepcopy(my_dict)

现在，如果您更改

    my_dict['a'][2] = 7

然后做

    print("my_copy a[2]: ",my_copy['a'][2],",whereas my_deepcopy a[2]: ", my_deepcopy['a'][2])

你得到

    >> my_copy a[2]:  7 ,whereas my_deepcopy a[2]:  3

Answer 6

更简单（在我看来）解决方案是创建一个新字典并使用旧字典的内容进行更新：

my_dict={'a':1}

my_copy = {}

my_copy.update( my_dict )

my_dict['a']=2

my_dict['a']
Out[34]: 2

my_copy['a']
Out[35]: 1

这种方法的问题是它可能不够“足够深”。即不是递归深度的。对于简单对象而言不够，但对于嵌套字典则不够。这是一个可能不够深的例子：

my_dict1={'b':2}

my_dict2={'c':3}

my_dict3={ 'b': my_dict1, 'c':my_dict2 }

my_copy = {}

my_copy.update( my_dict3 )

my_dict1['b']='z'

my_copy
Out[42]: {'b': {'b': 'z'}, 'c': {'c': 3}}

通过使用Deepcopy（），我可以消除半浅的行为，但我认为必须确定哪种方法适合您的应用程序。在大多数情况下，你可能不在乎，但应该意识到可能存在的陷阱......最后的例子：

import copy

my_copy2 = copy.deepcopy( my_dict3 )

my_dict1['b']='99'

my_copy2
Out[46]: {'b': {'b': 'z'}, 'c': {'c': 3}}

在python中的字典的深拷贝

6 个答案: