Python 口述中的差异

我试图找出dict中的区别，是添加了什么还是删除了什么，以及来自什么

以下是添加值的情况：

original = {0: None, 1: False, 2: [16]}
new = {0: None, 1: False, 2: [2, 16]}

difference = True, {2: 2} # True = Added

下面是一个删除值的情况：

original = {0: None, 1: False, 2: [16, 64]}
new = {0: None, 1: False, 2: [64]}

difference = False, {2: 16} # False = Removed

问题是我不知道如何接受差异。有谁会碰巧知道如何实现这样的结果

额外信息（不知道您是否需要此信息）：

• 这也适用于原始和新版本的0和1
• 1和2不能同时处于活动状态。如果一个有值，另一个为False

---

这里有一个指向一个函数的链接，该函数可以生成两个字典的“diff”，后跟其他注释/代码示例：

包括以下代码：

KEYNOTFOUND = '<KEYNOTFOUND>'       # KeyNotFound for dictDiff

def dict_diff(first, second):
    """ Return a dict of keys that differ with another config object.  If a value is
        not found in one fo the configs, it will be represented by KEYNOTFOUND.
        @param first:   Fist dictionary to diff.
        @param second:  Second dicationary to diff.
        @return diff:   Dict of Key => (first.val, second.val)
    """
    diff = {}
    # Check all keys in first dict
    for key in first.keys():
        if (not second.has_key(key)):
            diff[key] = (first[key], KEYNOTFOUND)
        elif (first[key] != second[key]):
            diff[key] = (first[key], second[key])
    # Check all keys in second dict to find missing
    for key in second.keys():
        if (not first.has_key(key)):
            diff[key] = (KEYNOTFOUND, second[key])
    return diff

KEYNOTFOUND=''#dictDiff的KEYNOTFOUND
def dict_diff（第一，第二）：
“”“返回与另一个配置对象不同的键的dict。如果值为
在一个配置中找不到，它将由KEYNOTFOUND表示。
@参数优先：第一个字典到差异。
@第二个参数：第二个表示差异。
@return diff:Dict of Key=>（first.val，second.val）
"""
差异={}
#检查第一个dict中的所有键
对于第一个键。键（）：
如果（不是第二个。有_键（键））：
diff[key]=（第一个[key]，KEYNOTFOUND）
elif（第一[键]！=第二[键]：
差异[键]=（第一[键]、第二[键]）
#检查第二个dict中的所有钥匙以查找丢失的钥匙
对于第二个中的键。键（）
如果（不是第一个。有_键（key））：
diff[key]=（KEYNOTFOUND，第二个[key]）
回差

您可以临时将dic[2]转移到python中的

集合

，然后使用

-

来获得差异

类似于：

def diff(a,b):
     ret_dict = {}
     for key,val in a.items():
         if b.has_key(key):
             if b[key] != val:
                 ret_dict[key] = [val,b[key]]
         else:
             ret_dict[key] = [val]
     for key,val in b.items():
         ret_dict.setdefault(key,[val])
     return ret_dict

---

正如我在一篇文章中所解释的，PyPI上有一个库专门用于此任务，这就是。它易于使用，您可以使用输出完成您必须完成的工作。

这可以在一行中完成

[b[k] for k in a.keys() if not k in b]

---

我觉得这很容易理解：

def dict_diff(left, right):
    diff = dict()
    diff['left_only'] = set(left) - set(right)
    diff['right_only'] = set(right) - set(left)
    diff['different'] = {k for k in set(left) & set(right) if left[k]!=right[k]}
    return diff

>>> d1 = dict(a=1, b=20, c=30, e=50)
>>> d2 = dict(a=1, b=200, d=400, e=500)
>>> dict_diff(d1, d2)
{'different': {'b', 'e'}, 'left_only': {'c'}, 'right_only': {'d'}}

---

为什么不在dict周围创建一个“包装器”，并使用它跟踪添加/删除内容的时间？（我不知道在python中这有多困难，但在c#中这相当简单。）您的问题没有明确说明。如果在第一个示例中删除16并添加2，会发生什么？区别必须同时是对的和错的。让我们假设这永远不会发生，phooji.）可能重复的