8

I'm trying to figure out the difference in a dict, whether something was added or removed and from what.

Here is a case where a value is added:

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

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

And here is a case where a value is removed:

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

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

The problem is that I have no idea how to recieve the difference. Would anyone happen to know how to achieve such a result?

Extra information (no idea if you'll need this):

  • This can apply to 0 and 1 of original and new as well.
  • 1 and 2 cannot be active at the same time. If one has values, the other is False.
S.L. Barth is on codidact.com
  • 8,198
  • 71
  • 51
  • 66
dbdii407
  • 815
  • 3
  • 11
  • 14
  • 1
    Why not create a "wrapper" around dict and use it to track when things are added/removed? (I don't know how hard that would be in python, but it's fairly simple in c#). – Michael Todd Jul 09 '11 at 02:08
  • Your problem is under specified. What happens if I remove 16 *and* add 2 in your first example? Difference would have to be both True and False at the same time. – phooji Jul 09 '11 at 02:11
  • Let's assume that will never happen, phooji. :) – dbdii407 Jul 09 '11 at 02:16
  • possible duplicate of [Fast comparison between two Python dictionary](http://stackoverflow.com/questions/1165352/fast-comparison-between-two-python-dictionary) – bummi Oct 28 '13 at 12:10

6 Answers6

6

As I've explained in an other question there is a library on PyPI just for this task, which is datadiff library. It's easy to use and you can use the output to do what you have to do.

Community
  • 1
  • 1
softwareplay
  • 1,379
  • 4
  • 28
  • 64
3

I find this quite readable:

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'}}
snth
  • 5,194
  • 4
  • 39
  • 48
2

Here is a link to a function that can produce a "diff" of two dictionaries, followed by additional comments/code samples:

http://code.activestate.com/recipes/576644-diff-two-dictionaries/

Including code below:

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
Nalum
  • 4,143
  • 5
  • 38
  • 55
AJ.
  • 27,586
  • 18
  • 84
  • 94
1

you may temporarily transfer dic[2] to a set in python, and use - to get the difference

taijirobot
  • 143
  • 1
  • 2
  • 8
0

What about something like:

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
Whoopska
  • 139
  • 5
-1

That can be done in one line.

[b[k] for k in a.keys() if not k in b]
Oleg Urzhumtsev
  • 1
  • 1