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

有人可以向我解释一下吗？这对我来说毫无意义。

我将字典复制到另一个字典中，然后编辑第二个字典，并且两者都已更改。为什么会这样呢？

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

Python 绝不会隐式复制对象。设置时dict2 = dict1，将使它们引用同一精确的dict对象，因此，在对它进行突变时，对其的所有引用都将始终引用该对象的当前状态。

如果要复制字典（这种情况很少见），则必须使用

dict2 = dict(dict1)

要么

dict2 = dict1.copy()

分配时dict2 = dict1，您并没有复制该文件的副本dict1，导致dict2它只是它的另一个名称dict1。

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

import copy

dict2 = copy.deepcopy(dict1)

虽然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模块docs：

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

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

在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（）。

最好的和最简单的方法创建一个副本一个的字典中都Python的2.7和3是...

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

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)

您也可以使用字典理解功能来制作新字典。这样可以避免导入副本。

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

当然，在python> = 2.7中，您可以执行以下操作：

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

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

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

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

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

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

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

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

最初，这也使我感到困惑，因为我来自C语言。

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

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

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？deepcopy将确保dict2（您是否将其指向列表？）的元素也是副本。

我用的不是deepcopy很多-在我看来，编写需要它的代码通常是不明智的做法。

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)

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

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

正如其他人所解释的，内置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-左值修改的纯语法。关键的观察是，str和int表现为在Python值（即使它们实际上是引擎盖下的不可变对象）。当您观察到这一点时，也请注意，关于str或，没有什么神奇的特别之处int。dict可以以几乎相同的方式使用，我可以想到很多ValueDict有意义的情况。

以下代码，是遵循json语法的字典的，比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)

尝试深复制类w / o将其分配给变量的字典属性时，遇到了一种特殊的行为

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

但是，如果您这样做old = my_class.a，那么new = copy.deepcopy(old)它会完美运行，即修改new不会影响my_class.a

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

因为dict2 = dict1，dict2保存了对dict1的引用。dict1和dict2都指向内存中的同一位置。这是在python中使用可变对象时的正常情况。使用python中的可变对象时，必须小心，因为它很难调试。如下面的例子。

 my_users = {
        'ids':[1,2],
        'blocked_ids':[5,6,7]
 }
 ids = my_users.get('ids')
 ids.extend(my_users.get('blocked_ids')) #all_ids
 print ids#output:[1, 2, 5, 6, 7]
 print my_users #output:{'blocked_ids': [5, 6, 7], 'ids': [1, 2, 5, 6, 7]}

此示例意图是获取所有用户ID，包括被阻止的ID。我们是从ids变量获得的，但是我们也无意间更新了my_users的值。当你扩展的IDS与blocked_ids my_users得到了更新，因为IDS参考my_users。

使用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}

您可以直接使用：

dict2 = eval(repr(dict1))

其中对象dict2是dict1的独立副本，因此您可以修改dict2而不会影响dict1。

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