Python dict.add_by_value (dict_2)?

решая не с точки зрения «длины», а производительности, я бы сделал следующее:

>>> from collections import defaultdict
>>> def d_sum(a, b):
        d = defaultdict(int, a)
        for k, v in b.items():
            d[k] += v
        return dict(d)
>>> a = {'a': 1, 'b': 2}
>>> b = {'c': 2, 'b': 3}
>>> d_sum(a, b)
{'a': 1, 'c': 2, 'b': 5}

он также совместим с py3k, в отличие от вашего исходного кода.

По моему первому впечатлению, я напишу:

>>> c = a.copy()
>>> for k in b: c[k] = c.get(k, 0) + b[k]

Если вам нужен сокращенный код, вы здесь.

Если вам нужен чистый код, наследуйте от Ber defaultdict и перегрузите __ add __ :

from collections import defaultdict

class summable(defaultdict):
    def __add__(self, rhs):
        new = summable()
        for i in (self.keys() + rhs.keys()):
            new[i] = self.get(i, 0) + rhs.get(i, 0)
        return new

a = summable(int, a=1, b=2)
b = summable(int, b=3, c=4)
c = a + b
print c

Выдает:

>>> 
defaultdict(None, {'a': 1, 'c': 4, 'b': 5})
>>> 

Я думаю, что одна строка кода уже довольно короткая :)

Я могу превратиться в «половину строки», если вы используете defaultdict , удалите ненужный список и установите создание:

from collections import defaultdict

a = defaultdict(int, a=1, b=2)
b = defaultdict(int, b=3, c=4)

c = dict((k, a[k]+b[k]) for k in (a.keys() + b.keys()))
print c

def GenerateSum():
  for k in set(a).union(b):
    yield k, a.get(k, 0) + b.get(k, 0)

e = dict(GenerateSum())
print e

или, с однострочным текстом:

 print dict((k, a.get(k,0) + b.get(k,0)) for k in set(a).union(b))

Первое, о чем я думаю, это немного эффективнее и (IMO) немного элегантнее, но все же слишком много набора текста. Фактически, это примерно эквивалентно kcwu.

c = reduce(lambda(d, k): [d.update({k: d.get(k, 0) + b[k]}), d][1], b, a.copy())

Очень жаль, что dict.update не возвращает self . Я думаю, это не способ Python. Если бы это было так, трюк [..., d] [1] был бы ненужным.

Perl: «Легкие вещи - легкие, сложные - возможны»

%a = (a => 1, b => 2);
%b = (b => 3, c => 2);

%c = (%a, map {$_ => $a{$_} + $b{$_}} keys %b);

Haskell: «Легкое - трудное, трудное - легкое» «Трудные вещи легко, невозможное просто произошло»

import qualified Data.Map as M

a = M.fromList [('a', 1), ('b', 2)]
b = M.fromList [('b', 3), ('c', 2)]

c = M.unionWith (+) a b

Комментарий к Ответ @John Pirie :

Вот реализация, которая не использует (self.keys () + rhs.keys ()) :

from collections import defaultdict

class sumdict(defaultdict):
    def __add__(self, rhs):
        d = self.copy() 
        d += rhs
        return d
    __radd__ = lambda self, lhs: self + lhs
    def __iadd__(self, rhs):
        for k, v in rhs.items():
            self[k] += v
        return self

a = sumdict(int, a=1, b=2)
b = dict(b=3, c=4)
c = b + a
a += b

assert a == c == {'a': 1, 'c': 4, 'b': 5} != b