In [1]:

    

a = {'a': 5, 'b': 1, 'c': -1, 'd': 1}
b = {'a': 1, 'b': 5, 'c': 1, 'e': 1}


    

In [2]:

    

def solution1(a, b):
    result = dict(a)
    for k, v in b.items():
        if result.get(k):
            result[k] += v
        else:
            result[k] = v
    return result

solution1(a, b)


    

    
Out[2]:





{'a': 6, 'b': 6, 'c': 0, 'd': 1, 'e': 1}

In [3]:

    

def solution2(a, b):
    result = dict(a)
    for k, v in b.items():
        try:
            result[k] += v
        except KeyError:
            result[k] = v
    return result

solution2(a, b)


    

    
Out[3]:





{'a': 6, 'b': 6, 'c': 0, 'd': 1, 'e': 1}

In [4]:

    

from collections import Counter

def solution3(a, b):
    return Counter(a) + Counter(b)

solution3(a, b)


    

    
Out[4]:





Counter({'a': 6, 'b': 6, 'd': 1, 'e': 1})

In [5]:

    

def solution4(a, b):
    intersection = set(a) & set(b)
    c = {k: a[k] + b[k] for k in intersection}
    return {**a, **b, **c}

solution4(a, b)


    

    
Out[5]:





{'a': 6, 'b': 6, 'c': 0, 'd': 1, 'e': 1}

In [6]:

    

solution5 = lambda a, b: {**a, **b, **{k: a[k] + b[k] for k in a.keys() & b}}
solution5(a, b)


    

    
Out[6]:





{'a': 6, 'b': 6, 'c': 0, 'd': 1, 'e': 1}

In [14]:

    

%timeit -n 100000 solution1(a, b)


    

    




1.56 µs ± 80.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [15]:

    

%timeit -n 100000 solution2(a, b)


    

    




1.61 µs ± 106 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [16]:

    

%timeit -n 100000 solution3(a, b)


    

    




11 µs ± 216 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [17]:

    

%timeit -n 100000 solution4(a, b)


    

    




2.01 µs ± 64.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [18]:

    

%timeit -n 100000 solution5(a, b)


    

    




2.08 µs ± 122 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [ ]: