Btukfyl

You can perform +, -, &, and | (intersection and union) on collections.Counter().

So we can do the following (Note: only positive count values will remain in the dictionary):

from collections import Counter



x = {'both1':1, 'both2':2, 'only_x': 100 }

y = {'both1':10, 'both2': 20, 'only_y':200 }



z = dict(Counter(x)+Counter(y))



print(z) # {'both2': 22, 'only_x': 100, 'both1': 11, 'only_y': 200}

To address adding values where the result may be zero or negative use Counter.update() for addition and Counter.subtract() for subtraction:

x = {'both1':0, 'both2':2, 'only_x': 100 }

y = {'both1':0, 'both2': -20, 'only_y':200 }

xx = Counter(x)

yy = Counter(y)

xx.update(yy)

dict(xx) # {'both2': -18, 'only_x': 100, 'both1': 0, 'only_y': 200}

You could use defaultdict for this:

from collections import defaultdict



def dsum(*dicts):

    ret = defaultdict(int)

    for d in dicts:

        for k, v in d.items():

            ret[k] += v

    return dict(ret)



x = {'both1':1, 'both2':2, 'only_x': 100 }

y = {'both1':10, 'both2': 20, 'only_y':200 }



print(dsum(x, y))

This produces

{'both1': 11, 'both2': 22, 'only_x': 100, 'only_y': 200}

Additional notes based on the answers of georg, NPE and Scott.

I was trying to perform this action on collections of 2 or more dictionaries and was interested in seeing the time it took for each. Because I wanted to do this on any number of dictionaries, I had to change some of the answers a bit. If anyone has better suggestions for them, feel free to edit.

Here's my test method. I've updated it recently to include tests with MUCH larger dictionaries:

Firstly I used the following data:

import random



x = {'xy1': 1, 'xy2': 2, 'xyz': 3, 'only_x': 100}

y = {'xy1': 10, 'xy2': 20, 'xyz': 30, 'only_y': 200}

z = {'xyz': 300, 'only_z': 300}



small_tests = [x, y, z]



# 200,000 random 8 letter keys

keys = [''.join(random.choice("abcdefghijklmnopqrstuvwxyz") for _ in range(8)) for _ in range(200000)]



a, b, c = {}, {}, {}



# 50/50 chance of a value being assigned to each dictionary, some keys will be missed but meh

for key in keys:

    if random.getrandbits(1):

        a[key] = random.randint(0, 1000)

    if random.getrandbits(1):

        b[key] = random.randint(0, 1000)

    if random.getrandbits(1):

        c[key] = random.randint(0, 1000)



large_tests = [a, b, c]



print("a:", len(a), "b:", len(b), "c:", len(c))

#: a: 100069 b: 100385 c: 99989

Now each of the methods:

from collections import defaultdict, Counter



def georg_method(tests):

    return {k: sum(t.get(k, 0) for t in tests) for k in set.union(*[set(t) for t in tests])}



def georg_method_nosum(tests):

    # If you know you will have exactly 3 dicts

    return {k: tests[0].get(k, 0) + tests[1].get(k, 0) + tests[2].get(k, 0) for k in set.union(*[set(t) for t in tests])}



def npe_method(tests):

    ret = defaultdict(int)

    for d in tests:

        for k, v in d.items():

            ret[k] += v

    return dict(ret)



# Note: There is a bug with scott's method. See below for details.

def scott_method(tests):

    return dict(sum((Counter(t) for t in tests), Counter()))



def scott_method_nosum(tests):

    # If you know you will have exactly 3 dicts

    return dict(Counter(tests[0]) + Counter(tests[1]) + Counter(tests[2]))



methods = {"georg_method": georg_method, "georg_method_nosum": georg_method_nosum,

           "npe_method": npe_method,

           "scott_method": scott_method, "scott_method_nosum": scott_method_nosum}

I also wrote a quick function find whatever differences there were between the lists. Unfortunately, that's when I found the problem in Scott's method, namely, if you have dictionaries that total to 0, the dictionary won't be included at all because of how Counter() behaves when adding.

Finally, the results:

Results: Small Tests

for name, method in methods.items():

    print("Method:", name)

    %timeit -n10000 method(small_tests)

#: Method: npe_method

#: 10000 loops, best of 3: 5.16 µs per loop

#: Method: georg_method_nosum

#: 10000 loops, best of 3: 8.11 µs per loop

#: Method: georg_method

#: 10000 loops, best of 3: 11.8 µs per loop

#: Method: scott_method_nosum

#: 10000 loops, best of 3: 42.4 µs per loop

#: Method: scott_method

#: 10000 loops, best of 3: 65.3 µs per loop

Results: Large Tests

Naturally, couldn't run anywhere near as many loops

for name, method in methods.items():

    print("Method:", name)

    %timeit -n10 method(large_tests)

#: Method: npe_method

#: 10 loops, best of 3: 227 ms per loop

#: Method: georg_method_nosum

#: 10 loops, best of 3: 327 ms per loop

#: Method: georg_method

#: 10 loops, best of 3: 455 ms per loop

#: Method: scott_method_nosum

#: 10 loops, best of 3: 510 ms per loop

#: Method: scott_method

#: 10 loops, best of 3: 600 ms per loop

Conclusion

╔═══════════════════════════╦═══════╦═════════════════════════════╗

║                           ║       ║   Best of 3 Time Per Loop   ║

║         Algorithm         ║  By   ╠══════════════╦══════════════╣

║                           ║       ║  small_tests ║  large_tests ║

╠═══════════════════════════╬═══════╬══════════════╬══════════════╣

║ defaultdict sum           ║ NPE   ║      5.16 µs ║   227,000 µs ║

║ set unions without sum()  ║ georg ║      8.11 µs ║   327,000 µs ║

║ set unions with sum()     ║       ║      11.8 µs ║   455,000 µs ║

║ Counter() without sum()   ║ Scott ║      42.4 µs ║   510,000 µs ║

║ Counter() with sum()      ║       ║      65.3 µs ║   600,000 µs ║

╚═══════════════════════════╩═══════╩══════════════╩══════════════╝

Important. YMMV.

Another options using a reduce function. This allows to sum-merge an arbitrary collection of dictionaries:

from functools import reduce



collection = [

    {'a': 1, 'b': 1},

    {'a': 2, 'b': 2},

    {'a': 3, 'b': 3},

    {'a': 4, 'b': 4, 'c': 1},

    {'a': 5, 'b': 5, 'c': 1},

    {'a': 6, 'b': 6, 'c': 1},

    {'a': 7, 'b': 7},

    {'a': 8, 'b': 8},

    {'a': 9, 'b': 9},

]





def reducer(accumulator, element):

    for key, value in element.items():

        accumulator[key] = accumulator.get(key, 0) + value

    return accumulator





total = reduce(reducer, collection, {})





assert total['a'] == sum(d.get('a', 0) for d in collection)

assert total['b'] == sum(d.get('b', 0) for d in collection)

assert total['c'] == sum(d.get('c', 0) for d in collection)



print(total)

Execution:

{'a': 45, 'b': 45, 'c': 3}

Advantages:

• Simple, clear, Pythonic.


• Schema-less, as long all keys are "sumable".


• O(n) temporal complexity and O(1) memory complexity.

I suspect you're looking for dict's update method:

>>> d1 = {1:2,3:4}

>>> d2 = {5:6,7:8}

>>> d1.update(d2)

>>> d1

{1: 2, 3: 4, 5: 6, 7: 8}

d1 = {'apples': 2, 'banana': 1}

d2 = {'apples': 3, 'banana': 2}

merged = reduce(

    lambda d, i: (

        d.update(((i[0], d.get(i[0], 0) + i[1]),)) or d

    ),

    d2.iteritems(),

    d1.copy(),

)

There is also pretty simple replacement of dict.update():

merged = dict(d1, **d2)

If you want to create a new dict as | use:

>>> dict({'a': 1,'c': 2}, **{'c': 1})

{'a': 1, 'c': 1}

class dict_merge(dict):

def __add__(self, other):

    result = dict_merge({})

    for key in self.keys():

        if key in other.keys():

            result[key] = self[key] + other[key]

        else:

            result[key] = self[key]

    for key in other.keys():

        if key in self.keys():

            pass

        else:

            result[key] = other[key]

    return result





a = dict_merge({"a":2, "b":3, "d":4})

b = dict_merge({"a":1, "b":2})

c = dict_merge({"a":5, "b":6, "c":5})

d = dict_merge({"a":8, "b":6, "e":5})



print((a + b + c +d))





>>> {'a': 16, 'b': 17, 'd': 4, 'c': 5, 'e': 5}

That is operator overloading. Using __add__, we have defined how to use the operator + for our dict_merge which inherits from the inbuilt python dict. You can go ahead and make it more flexible using a similar way to define other operators in this same class e.g. * with __mul__ for multiplying, or / with __div__ for dividing, or even % with __mod__ for modulo, and replacing the + in self[key] + other[key] with the corresponding operator, if you ever find yourself needing such merging.
I have only tested this as it is without other operators but I don't foresee a problem with other operators. Just learn by trying.