如何复制字典并只编辑副本

Question

我设置dict2 = dict1 。 当我编辑dict2时，原来的dict1也会发生变化。 为什么？

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict1
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key2': 'WHY?!', 'key1': 'value1'}

Answer 1

Python从不隐式复制对象。 当您设置dict2 = dict1 ，您正在使它们引用相同的确切 dict 对象，因此当您对其进行变异时，对它的所有引用都会继续引用其当前状态的对象。

如果你想复制字典（这很少见），你必须明确地这样做

dict2 = dict(dict1)

或者

dict2 = dict1.copy()

Answer 2

当你将dict2 = dict1 ，你是不是做的副本dict1 ，它导致dict2是为另一个名称而已dict1 。

要复制字典等可变类型，请使用copy模块的copy / deepcopy 。

import copy

dict2 = copy.deepcopy(dict1)

Answer 3

虽然dict.copy()和dict(dict1)生成一个副本，但它们只是浅拷贝。 如果你想要一个深拷贝， copy.deepcopy(dict1)是必需的。 一个例子：

>>> source = {'a': 1, 'b': {'m': 4, 'n': 5, 'o': 6}, 'c': 3}
>>> copy1 = x.copy()
>>> copy2 = dict(x)
>>> import copy
>>> copy3 = copy.deepcopy(x)
>>> source['a'] = 10  # a change to first-level properties won't affect copies
>>> source
{'a': 10, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> copy3
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}
>>> source['b']['m'] = 40  # a change to deep properties WILL affect shallow copies 'b.m' property
>>> source
{'a': 10, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy1
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy2
{'a': 1, 'c': 3, 'b': {'m': 40, 'o': 6, 'n': 5}}
>>> copy3  # Deep copy's 'b.m' property is unaffected
{'a': 1, 'c': 3, 'b': {'m': 4, 'o': 6, 'n': 5}}

关于浅拷贝和深拷贝，来自Python copy模块文档：

浅拷贝和深拷贝之间的区别仅与复合对象（包含其他对象的对象，如列表或类实例）相关：

• 浅拷贝构造一个新的复合对象，然后（在可能的范围内）将对原始对象中的对象的引用插入其中。
• 深拷贝构造一个新的复合对象，然后递归地将在原始对象中找到的对象的副本插入其中。

Answer 4

深度和简单的记忆方法：

每当您执行 dict2 = dict1 时，dict2 指的是 dict1。 dict1 和 dict2 都指向内存中的相同位置。 这只是在 python 中使用可变对象时的正常情况。 当你在 python 中使用可变对象时，你必须小心，因为它很难调试。

而不是使用 dict2 = dict1，您应该使用 python复制模块中的复制（浅复制）和deepcopy方法将 dict2 与 dict1 分开。

正确的方法是：

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict1.copy()
>>> dict2
{'key1': 'value1', 'key2': 'value2'}
>>> dict2["key2"] = "WHY?"
>>> dict2
{'key1': 'value1', 'key2': 'WHY?'}
>>> dict1
{'key1': 'value1', 'key2': 'value2'}
>>> id(dict1)
140641178056312
>>> id(dict2)
140641176198960
>>> 

如您所见， dict1 和 dict2 的id不同，这意味着两者都指向/引用内存中的不同位置。

此解决方案适用于具有不可变值的字典，这对于具有可变值的字典不是正确的解决方案。

例如：

>>> import copy
>>> dict1 = {"key1" : "value1", "key2": {"mutable": True}}
>>> dict2 = dict1.copy()
>>> dict2
{'key1': 'value1', 'key2': {'mutable': True}}
>>> dict2["key2"]["mutable"] = False
>>> dict2
{'key1': 'value1', 'key2': {'mutable': False}}
>>> dict1
{'key1': 'value1', 'key2': {'mutable': False}}
>>> id(dict1)
140641197660704
>>> id(dict2)
140641196407832
>>> id(dict1["key2"])
140641176198960
>>> id(dict2["key2"])
140641176198960

您可以看到，即使我们为 dict1 应用了副本，但 mutable 的值在 dict2 和 dict1 上都更改为 false，即使我们只在 dict2 上更改它。 这是因为我们更改了 dict1 的可变 dict 部分的值。 当我们在 dict 上应用一个副本时，它只会做一个浅拷贝，这意味着它将所有不可变值复制到一个新的 dict 中并且不复制可变值但它会引用它们。

最终的解决方案是对 dict1 进行 deepycopy 以完全创建一个新的 dict，其中包含复制的所有值，包括可变值。

>>>import copy
>>> dict1 = {"key1" : "value1", "key2": {"mutable": True}}
>>> dict2 = copy.deepcopy(dict1)
>>> dict2
{'key1': 'value1', 'key2': {'mutable': True}}
>>> id(dict1)
140641196228824
>>> id(dict2)
140641197662072
>>> id(dict1["key2"])
140641178056312
>>> id(dict2["key2"])
140641197662000
>>> dict2["key2"]["mutable"] = False
>>> dict2
{'key1': 'value1', 'key2': {'mutable': False}}
>>> dict1
{'key1': 'value1', 'key2': {'mutable': True}}

如您所见，id 不同，这意味着 dict2 完全是一个新的 dict，其中包含 dict1 中的所有值。

如果您想更改任何可变值而不影响原始字典，则需要使用 Deepcopy。 如果没有，您可以使用浅拷贝。 Deepcopy 很慢，因为它递归地复制原始字典中的任何嵌套值，并且还需要额外的内存。

Answer 5

在 python 3.5+ 上，有一种更简单的方法可以通过使用 ** 解包操作符来实现浅拷贝。 由Pep 448定义。

>>>dict1 = {"key1": "value1", "key2": "value2"}
>>>dict2 = {**dict1}
>>>print(dict2)
{'key1': 'value1', 'key2': 'value2'}
>>>dict2["key2"] = "WHY?!"
>>>print(dict1)
{'key1': 'value1', 'key2': 'value2'}
>>>print(dict2)
{'key1': 'value1', 'key2': 'WHY?!'}

** 将字典解包成一个新字典，然后分配给 dict2。

我们还可以确认每个字典都有一个不同的 id。

>>>id(dict1)
 178192816

>>>id(dict2)
 178192600

如果需要深拷贝，那么copy.deepcopy()仍然是要走的路。

Answer 6

在Python 2.7 和 3中创建dict副本的最佳和最简单的方法是...

要创建简单（单级）字典的副本：

1.使用dict()方法，而不是生成指向现有 dict 的引用。

my_dict1 = dict()
my_dict1["message"] = "Hello Python"
print(my_dict1)  # {'message':'Hello Python'}

my_dict2 = dict(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

2.使用python字典内置的update()方法。

my_dict2 = dict()
my_dict2.update(my_dict1)
print(my_dict2)  # {'message':'Hello Python'}

# Made changes in my_dict1 
my_dict1["name"] = "Emrit"
print(my_dict1)  # {'message':'Hello Python', 'name' : 'Emrit'}
print(my_dict2)  # {'message':'Hello Python'}

要创建嵌套或复杂字典的副本：

使用内置的复制模块，它提供了通用的浅拷贝和深拷贝操作。 该模块存在于 Python 2.7 和 3 中。*

import copy

my_dict2 = copy.deepcopy(my_dict1)

Answer 7

您也可以只制作具有字典理解的新字典。 这样可以避免导入副本。

dout = dict((k,v) for k,v in mydict.items())

当然在 python >= 2.7 你可以这样做：

dout = {k:v for k,v in mydict.items()}

但是对于向后兼容，top 方法更好。

Answer 8

除了提供的其他解决方案外，您还可以使用**将字典集成到一个空字典中，例如，

shallow_copy_of_other_dict = {**other_dict} 。

现在您将拥有other_dict的“浅”副本。

应用于您的示例：

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = {**dict1}
>>> dict2
{'key1': 'value1', 'key2': 'value2'}
>>> dict2["key2"] = "WHY?!"
>>> dict1
{'key1': 'value1', 'key2': 'value2'}
>>>

指针：浅拷贝和深拷贝的区别

Answer 9

Python 中的赋值语句不复制对象，它们在目标和对象之间创建绑定。

因此， dict2 = dict1 ，它导致dict2和dict1引用的对象之间的另一个绑定。

如果你想复制一个字典，你可以使用copy module 。 复制模块有两个接口：

copy.copy(x)
Return a shallow copy of x.

copy.deepcopy(x)
Return a deep copy of x.

浅拷贝和深拷贝之间的区别仅与复合对象（包含其他对象的对象，如列表或类实例）相关：

浅拷贝构造一个新的复合对象，然后（在可能的范围内）将对原始对象中的对象的引用插入其中。

深拷贝构造一个新的复合对象，然后递归地将在原始对象中找到的对象的副本插入其中。

例如，在 python 2.7.9 中：

>>> import copy
>>> a = [1,2,3,4,['a', 'b']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> a.append(5)
>>> a[4].append('c')

结果是：

>>> a
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> b
[1, 2, 3, 4, ['a', 'b', 'c'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c']]
>>> d
[1, 2, 3, 4, ['a', 'b']]

Answer 10

最初，这也让我感到困惑，因为我来自 C 背景。

在 C 中，变量是内存中具有已定义类型的位置。 分配给变量会将数据复制到变量的内存位置。

但在 Python 中，变量更像是指向对象的指针。 因此，将一个变量分配给另一个变量不会产生副本，它只会使该变量名指向同一个对象。

Answer 11

您可以通过使用附加关键字参数调用dict构造函数一次性复制和编辑新构造的副本：

>>> dict1 = {"key1": "value1", "key2": "value2"}
>>> dict2 = dict(dict1, key2="WHY?!")
>>> dict1
{'key2': 'value2', 'key1': 'value1'}
>>> dict2
{'key2': 'WHY?!', 'key1': 'value1'}

Answer 12

python 中的每个变量（诸如dict1或str或__builtins__类的东西都是指向机器内部某些隐藏的柏拉图式“对象”的指针。

如果设置dict1 = dict2 ，你只要点dict1同一对象（或存储器位置，或任何比喻你等）作为dict2 。 现在，引用的对象dict1是引用的同一个对象dict2 。

您可以检查： dict1 is dict2应该是True 。 此外， id(dict1)应该与id(dict2)相同。

你想要dict1 = copy(dict2)或dict1 = deepcopy(dict2) 。

copy和deepcopy copy的区别？ deepcopy将确保dict2的元素（您是否将其指向列表？）也是副本。

我很少使用deepcopy - 编写需要它的代码通常是不好的做法（在我看来）。

Answer 13

dict1是一个引用底层字典对象的符号。 将dict1分配给dict2仅分配相同的引用。 通过dict2符号更改键的值会更改底层对象，这也会影响dict1 。 这令人困惑。

对不可变值进行推理比引用要容易得多，因此请尽可能进行复制：

person = {'name': 'Mary', 'age': 25}
one_year_later = {**person, 'age': 26}  # does not mutate person dict

这在语法上与以下内容相同：

one_year_later = dict(person, age=26)

Answer 14

>>> dict2 = dict1
# dict2 is bind to the same Dict object which binds to dict1, so if you modify dict2, you will modify the dict1

复制 Dict 对象的方法有很多，我简单地使用

dict_1 = {
           'a':1,
           'b':2
         }
dict_2 = {}
dict_2.update(dict_1)

Answer 15

dict2 = dict1不复制字典。 它只是为程序员提供了第二种方式（ dict2 ）来引用同一个字典。

Answer 16

下面的代码，它遵循 json 语法的 dicts 比 deepcopy 快 3 倍以上

def CopyDict(dSrc):
    try:
        return json.loads(json.dumps(dSrc))
    except Exception as e:
        Logger.warning("Can't copy dict the preferred way:"+str(dSrc))
        return deepcopy(dSrc)

Answer 17

正如其他人所解释的那样，内置的dict不会做你想做的事。 但是在 Python2（也可能是 3）中，您可以轻松地创建一个使用=复制的ValueDict类，因此您可以确保原始数据不会改变。

class ValueDict(dict):

    def __ilshift__(self, args):
        result = ValueDict(self)
        if isinstance(args, dict):
            dict.update(result, args)
        else:
            dict.__setitem__(result, *args)
        return result # Pythonic LVALUE modification

    def __irshift__(self, args):
        result = ValueDict(self)
        dict.__delitem__(result, args)
        return result # Pythonic LVALUE modification

    def __setitem__(self, k, v):
        raise AttributeError, \
            "Use \"value_dict<<='%s', ...\" instead of \"d[%s] = ...\"" % (k,k)

    def __delitem__(self, k):
        raise AttributeError, \
            "Use \"value_dict>>='%s'\" instead of \"del d[%s]" % (k,k)

    def update(self, d2):
        raise AttributeError, \
            "Use \"value_dict<<=dict2\" instead of \"value_dict.update(dict2)\""


# test
d = ValueDict()

d <<='apples', 5
d <<='pears', 8
print "d =", d

e = d
e <<='bananas', 1
print "e =", e
print "d =", d

d >>='pears'
print "d =", d
d <<={'blueberries': 2, 'watermelons': 315}
print "d =", d
print "e =", e
print "e['bananas'] =", e['bananas']


# result
d = {'apples': 5, 'pears': 8}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
d = {'apples': 5, 'pears': 8}
d = {'apples': 5}
d = {'watermelons': 315, 'blueberries': 2, 'apples': 5}
e = {'apples': 5, 'pears': 8, 'bananas': 1}
e['bananas'] = 1

# e[0]=3
# would give:
# AttributeError: Use "value_dict<<='0', ..." instead of "d[0] = ..."

请参考此处讨论的左值修改模式： Python 2.7 - clean syntax for lvalue modify 。 关键的观察是str和int在 Python 中表现为值（即使它们实际上是引擎盖下的不可变对象）。 当您观察到这一点时，还请注意str或int没有什么特别之处。 dict可以以几乎相同的方式使用，我可以想到许多ValueDict有意义的情况。

Answer 18

因为python使用引用来工作，所以当您执行dict2 = dict1时，您将对dict2的引用传递给了dict1。 因此，当您对dict1或dict2进行更改时，您将更改引用，并且两个dict都改变了。 对不起，如果我在英语上弄错了。

Answer 19

很好的解释，我想添加一个最简单的规则，当您考虑用=分配的Python变量时可以参考。 如果数据类型是不可变的，则不必担心遇到的意外行为。 如果数据类型是可变的，则需要确保对其进行复制，以防止遇到意外的行为。

不可变的数据类型 ：字符串（字符的元组），元组

可变数据类型 ：列表，数组，字典

Answer 20

在尝试深度复制类的字典属性而不将其分配给变量时，我遇到了一种特殊的行为

new = copy.deepcopy(my_class.a)不起作用，即修改new修改my_class.a

但是如果你做old = my_class.a然后new = copy.deepcopy(old)它完美地工作，即修改new不会影响my_class.a

我不确定为什么会发生这种情况，但希望它有助于节省一些时间！ :)

Answer 21

对于嵌套字典，不要使用dict(srcData) or srcData.copy() or {**srcData}因为如果您更改第二级或更多，它也会修改源字典

srcData = {
  'first': {
    'second': 'second Value'
  }
}
newData = dict(srcData) # srcData.copy() or {**srcData}
newData['first']['second'] = 'new Second Value'

print(srcData)
print(newData)

# it will print
# srcData: {'first': {'second': 'new Second Value'}}
# newData:{'first': {'second': 'new Second Value'}}

# but it should be
# srcData: {'first': {'second': 'second Value'}}
# newData:{'first': {'second': 'new Second Value'}}

deepcopy 的另一个选择是使用json技巧，例如 Javascript JSON.parse(JSON.stringify(obj))

import json

srcData = {'first': {'second': 'second Value'}}
newData = json.loads(json.dumps(srcData))
newData['first']['second'] = 'new Second Value'

print(srcData)
print(newData)

# srcData: {'first': {'second': 'second Value'}}
# newData: {'first': {'second': 'new Second Value'}}

Answer 22

如果你的dict被输入为Mapping ，你不能.copy()它，但你可以

dict2 = dict1 | {}

它有点神秘，与copy.copy(dict1)相比我不能说性能，但它非常简洁。

Answer 23

使用 for 循环复制：

orig = {"X2": 674.5, "X3": 245.0}

copy = {}
for key in orig:
    copy[key] = orig[key]

print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 674.5, 'X3': 245.0}
copy["X2"] = 808
print(orig) # {'X2': 674.5, 'X3': 245.0}
print(copy) # {'X2': 808, 'X3': 245.0}

Answer 24

你可以直接使用：

dict2 = eval(repr(dict1))

其中object dict2是dict1的独立副本，所以可以修改dict2而不影响dict1。

这适用于任何类型的对象。

Answer 25

另一种更清洁的方法是使用 json。 见下面的代码

>>> a = [{"name":"Onkar","Address": {"state":"MH","country":"India","innerAddress":{"city":"Pune"}}}]
>>> b = json.dumps(a)
>>> b = json.loads(b)
>>> id(a)
2334461105416
>>> id(b)
2334461105224
>>> a[0]["Address"]["innerAddress"]["city"]="Nagpur"
>>> a
[{'name': 'Onkar', 'Address': {'state': 'MH', 'country': 'India', 'innerAddress': {'city': 'Nagpur'}}}]
>>> b
[{'name': 'Onkar', 'Address': {'state': 'MH', 'country': 'India', 'innerAddress': {'city': 'Pune'}}}]
>>> id(a[0]["Address"]["innerAddress"])
2334460618376
>>> id(b[0]["Address"]["innerAddress"])
2334424569880

要创建另一个字典，请在同一个字典对象上执行 json.dumps() 然后 json.loads() 。 您将有单独的 dict 对象。