在python中的字典的深拷贝

Deep copy of a dict in python

我想用python制作一个dict的深度拷贝。不幸的是，.deepcopy()方法不存在于dict中。我该怎么做？

1
2
3
4
5
6
7
8
9

>>> 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兼容。

相关讨论

怎么样：

1
2
3

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

Python 2或3：

1
2
3
4
5
6
7
8
9

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

相关讨论

这确实适用于我给出的过于简单的例子。我的钥匙不是数字而是物体。如果我阅读了复制模块文档，我必须为键声明一个uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu非常感谢你带我去那里！
python 3.2和2.7代码有什么区别吗？它们对我来说似乎是一样的。如果是这样的话，最好是一块代码和一条语句"同时适用于Python3和2"。
值得一提的是，copy.deepcopy不是线程安全的。很难学会这一点。另一方面，根据您的用例，json.loads(json.dumps(d))是线程安全的，并且工作得很好。
@罗布，你应该把这个评论作为答案。这是一个可行的选择。螺纹安全细微差别是一个重要区别。
当然，我想我们也可以将copy.deepcopy包装在一个自行开发的线程安全函数中？
@buvinj问题是，对于python dict属性不可序列化的所有用例，json.loads并不能解决问题。它可以帮助那些只处理简单的数据结构的人，例如从API，但我认为它不足以完全回答OP的问题。
@Rob，我理解这个限制。感谢您发表评论。你可能给我省去了一些麻烦。
另一个有趣的事实：dict的deepcopy并不总是保持元素的顺序：d = dict() ; for n in range(8): d[(n,n+1)] = n ; assert d.keys() == copy.deepcopy(d).keys() 。
@罗布，你能让我相信json.dumps是threadsafe吗？这个答案似乎与这个假设相矛盾：stackoverflow.com/a/23781650
这里缺少线程安全意味着什么？也就是说，从多个线程复制my_dict是否安全，只要my_dict在此过程中没有被修改？
"线程安全"是一个相当无意义的术语，除非您使用它的相反词"非线程安全"。线程安全意味着对行为的期望，但它没有详细说明哪种行为。库作者所考虑的线程安全可能与库用户所考虑的不同。例如，如果在多个线程上使用某个集合，它是否足以使其本身不损坏？您是否需要对count > 0进行检查，然后隐式读取第一项以保持一致？一般来说，只要阅读一些没有副作用的东西，阅读就是线程安全的。

dict.copy()是字典的一个浅拷贝函数id是一个内置函数，它提供变量的地址

首先，你需要理解"为什么会发生这个特殊的问题？"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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"的两个dict中的列表地址指向同一位置。因此，当您更改"我的字典"中列表的值时，"我的副本"中的列表也会更改。

解决方案：

1
2
3
4

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

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

或者您可以使用上面提到的deepcopy。

相关讨论

Python 3 x

从复制导入deepcopy

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

如果没有deepcopy，我无法从域字典中删除主机名字典。

如果没有deepcopy，我会得到以下错误：

1	"RuntimeError: dictionary changed size during iteration"

…当我试图从另一本字典中删除所需元素时。

1
2
3

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

域是字典对象

1
2
3
4
5
6
7

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]域='localdomain'：'localhost'：'all'：'4000'

[新]域='本地域'：

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

相关讨论

一个更简单的(在我看来)解决方案是创建一个新字典并用旧字典的内容更新它：

1
2
3
4
5
6
7
8
9
10
11
12
13

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

这种方法的问题在于它可能不够"深入"。也就是说，不是递归深度。对于简单的对象来说已经足够好了，但对于嵌套字典来说就不够好了。下面是一个可能不够深的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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()，我可以消除半浅层的行为，但我认为必须决定哪种方法适合您的应用程序。在大多数情况下，你可能不在乎，但应该意识到可能的陷阱…最后的例子：

1
2
3
4
5
6
7
8

import copy

my_copy2 = copy.deepcopy( my_dict3 )

my_dict1['b']='99'

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

相关讨论