蟒蛇dict.add_by_value（dict_2）？蟒蛇dict.add_by_value（di

问题：

>>> a = dict(a=1,b=2    )
>>> b = dict(    b=3,c=2)

>>> c = ???

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

所以，这个想法是二通过INT /浮点值在最短的形式添加到字典中。 下面是我想出一个解决办法，但我不喜欢它，因为它是长：

c = dict([(i,a.get(i,0) + b.get(i,0)) for i in set(a.keys()+b.keys())])

我认为必须有一个更短/简洁的解决方案（也许是与减少和运营商模块？itertools？）...任何想法？

---

更新：我真的很希望能找到更多的东西一样优雅 “减少（operator.add，键= itemgetter（0），A + B）”。 （显然，这不是真正的代码，但你应该明白我的意思）。 但似乎这可能是一个梦想。

---

更新：仍然寻找热塑成型更简洁的解决方案。 也许GROUPBY能帮忙吗？ 该解决方案，我想出了使用“减少” /“GROUPBY”实际上不是简洁：

from itertools import groupby
from operator import itemgetter,add

c = dict( [(i,reduce(add,map(itemgetter(1), v))) \
              for i,v in groupby(sorted(a.items()+b.items()), itemgetter(0))] )

Answer 1:

简单的方法就是用一个Counter

>>> from collections import Counter
>>> a = dict(a=1,b=2    )
>>> b = dict(    b=3,c=2)
>>> Counter(a)+Counter(b)
Counter({'b': 5, 'c': 2, 'a': 1})
>>> dict(Counter({'b': 5, 'c': 2, 'a': 1}))
{'a': 1, 'c': 2, 'b': 5}

Answer 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兼容，不像原来的代码。

Answer 3:

在我的第一印象，我会写：

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

Answer 4:

如果你想短码，你在那里。

如果你想要干净的代码，从误码率的继承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})
>>> 

Answer 5:

I think one line of code is already pretty short :)

I may become "half a line", it you use defaultdict and remove some unnecessary list and set creations:

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

Answer 6:

我想到的第一件事情是有点更有效和（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);

哈斯克尔：“容易的事情是很难，很难的事情很容易”，“困难的事情是容易的，不可能就这样发生了”

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

Answer 7:

注释为@约翰皮里的回答 ：

下面是不使用实施(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

Answer 8:

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))

文章来源: python dict.add_by_value(dict_2)?