如何对字典元素求和

问题描述：

在 Python 中，我有字典列表：

dict1 = [{'a':2, 'b':3},{'a':3, 'b':4}]

我想要一个包含所有字典总和的最终字典。结果将是：{'a':5, 'b':7}

注意：列表中的每个字典都包含相同数量的键和值对。

解决方案 1：

您可以使用collections.Counter

counter = collections.Counter()
for d in dict1: 
    counter.update(d)

或者，如果你更喜欢单行代码：

functools.reduce(operator.add, map(collections.Counter, dict1))

解决方案 2：

有点丑陋，但只有一行：

dictf = reduce(lambda x, y: dict((k, v + y[k]) for k, v in x.iteritems()), dict1)

解决方案 3：

sum()添加多个字典时，杠杆应该会获得更好的性能

>>> dict1 = [{'a':2, 'b':3},{'a':3, 'b':4}]
>>> from operator import itemgetter
>>> {k:sum(map(itemgetter(k), dict1)) for k in dict1[0]}        # Python2.7+
{'a': 5, 'b': 7}
>>> dict((k,sum(map(itemgetter(k), dict1))) for k in dict1[0])  # Python2.6
{'a': 5, 'b': 7}

添加 Stephan 的建议

>>> {k: sum(d[k] for d in dict1) for k in dict1[0]}            # Python2.7+
{'a': 5, 'b': 7}
>>> dict((k, sum(d[k] for d in dict1)) for k in dict1[0])      # Python2.6
{'a': 5, 'b': 7}

我认为 Stephan 版本的 Python2.7 代码读起来非常好

解决方案 4：

这可能会有帮助：

def sum_dict(d1, d2):
    for key, value in d1.items():
        d1[key] = value + d2.get(key, 0)
    return d1

>>> dict1 = [{'a':2, 'b':3},{'a':3, 'b':4}]
>>> reduce(sum_dict, dict1)
{'a': 5, 'b': 7}

解决方案 5：

下面的代码展示了一种方法：

dict1 = [{'a':2, 'b':3},{'a':3, 'b':4}]

final = {}
for k in dict1[0].keys():           # Init all elements to zero.
    final[k] = 0
for d in dict1:
    for k in d.keys():
        final[k] = final[k] + d[k]  # Update the element.

print final

输出：

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

如您所愿。

或者，受到 kriss 的启发，更好但仍然可读：

dict1 = [{'a':2, 'b':3},{'a':3, 'b':4}]

final = {}
for d in dict1:
    for k in d.keys():
        final[k] = final.get(k,0) + d[k]

print final

我怀念最初的、可读的 Python 时代 :-)

解决方案 6：

我对所提出的 Counter、reduce 和 sum 方法对大型列表的性能很感兴趣。也许其他人也对此感兴趣。你可以在这里查看：https://gist.github.com/torstenrudolf/277e98df296f23ff921c

我针对此词典列表测试了三种方法：

dictList = [{'a': x, 'b': 2*x, 'c': x**2} for x in xrange(10000)]

sum 方法性能最好，其次是 reduce，Counter 最慢。下面显示的时间以秒为单位。

In [34]: test(dictList)
Out[34]: 
{'counter': 0.01955194902420044,
 'reduce': 0.006518083095550537,
 'sum': 0.0018319153785705566}

但这取决于字典中元素的数量。 sum 方法的速度会比 reduce 方法更快。

l = [{y: x*y for y in xrange(100)} for x in xrange(10000)]

In [37]: test(l, num=100)
Out[37]: 
{'counter': 0.2401433277130127,
 'reduce': 0.11110662937164306,
 'sum': 0.2256883692741394}

解决方案 7：

您还可以使用 pandas sum函数来计算总和：

import pandas as pd
# create a DataFrame
df = pd.DataFrame(dict1)
# compute the sum and convert to dict.
dict(df.sum())

其结果是：

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

它也适用于浮点数：

dict2 = [{'a':2, 'b':3.3},{'a':3, 'b':4.5}]
dict(pd.DataFrame(dict2).sum())

给出正确的结果：

{'a': 5.0, 'b': 7.8}

解决方案 8：

在 Python 2.7 中，你可以用collections.Counter对象替换 dict 。这支持计数器的加法和减法。

解决方案 9：

这是一个合理而美丽的。

final = {}
for k in dict1[0].Keys():
    final[k] = sum(x[k] for x in dict1)
return final

解决方案 10：

这是另一个可行的解决方案（python3），非常通用，因为它适用于字典、列表、数组。对于非常见元素，原始值将包含在输出字典中。

def mergsum(a, b):
    for k in b:
        if k in a:
            b[k] = b[k] + a[k]
    c = {**a, **b}
    return c

dict1 = [{'a':2, 'b':3},{'a':3, 'b':4}]
print(mergsum(dict1[0], dict1[1]))

解决方案 11：

另一个一行解决方案

dict(
    functools.reduce(
        lambda x, y: x.update(y) or x,  # update, returns None, and we need to chain.
        dict1,
        collections.Counter())
)

这只会创建一个计数器，将其用作累加器并最后转换回字典。