Python 如何使用权重将词典合并在一起？

如何将这些字典合并在一起（如果重叠，则使用权重合并多个值）

该函数将返回：

d1 = {'weight':1, 'data': { 'apples': 8, 'oranges': 7 } }
d2 = {'weight':3, 'data': { 'apples': 4, 'bananas': 3 } }
all_dictionaries = [d1, d2, ... ]

def mergeDictionariesWithWeight(all_dictionaries)

苹果是

4

，因为

8*.25+4*.75

编辑：我刚刚写了一个，取平均值，类似这样的。当然，这和我想做的是完全不同的，因为我把所有的东西都放在一个列表中，然后除以长度

{ 'apples': 4, 'oranges': 7, 'bananas': 3 }

---

这里有一个解决方案，首先使用临时dict将项目收集到一个列表中，然后计算最终的加权dict。这可能不需要临时dict就可以完成，但这很容易理解

result = {}
keymap = {}
for the_dict in dlist:
    for (k, v) in the_dict.items():
        if not keymap.has_key(k):
            keymap[k] = []
        keymap[k].append(v)
for (k, v) in keymap.items():
    average = sum(int(x) for x in keymap[k]) / float(len(keymap[k]))
    result[k] = float(average)
return result

返回：{'apples'：5.0，'oranges'：7，'banana'：3}（因为8*.25+4*.75=5.0）

尝试以下操作：

def合并字典与权重（所有字典）： 加权和=0 权重字典={} 对于所有字典中的字典： 权重=字典['weight'] 数据=字典['data'] #查找数据中元素的总权重 对于data.items（）中的（k，v）： 如果字典中有k： 权重字典[k]+=权重*v 权重总和+=权重 #通过按权重和进行偏差来规范化结果 对于weightDictionary中的（键、值）： weightDictionary[键]=值/浮点（weightSum） 返回权重字典 d1={'weight'：1，'data'：{'apples'：8，'oranges'：7} d2={‘重量’：3，‘数据’：{‘苹果’：4，‘香蕉’：3} 所有字典=[d1，d2] 合并字典和权重（所有字典） 如果需要浮点结果

>>> from collections import defaultdict
>>> d=defaultdict(lambda:(0,0))
>>> for D in all_dictionaries:
...   weight = D['weight']
...   for k,v in D['data'].items():
...     d[k]=d[k][0]+weight*v,d[k][1]+weight
... 
>>> dict((k,v[0]/v[1]) for k,v in d.items())
{'apples': 5, 'oranges': 7, 'bananas': 3}

关于

通常您会看到

defaultdict（int）

或

defaultdict（list）

甚至

defaultdict（set）

。defaultdict的参数必须是无参数可调用的。只要发现缺少密钥，就会使用调用此参数的结果。ie-调用此函数将返回字典的默认值

比如说

>>> dict((k,1.*v[0]/v[1]) for k,v in d.items())
{'apples': 5.0, 'oranges': 7.0, 'bananas': 3.0}

这通常用于计数，因为

int（）

返回0。如果希望默认值为1而不是0，则更为棘手，因为无法将参数传递给int，但只需要返回1的可调用函数。这可以通过使用功能轻松完成

>>> d=defaultdict(int)
>>> d[1]
0
>>> d['foo']
0

在这个答案中，我想记录加权总数，以及权重的总和。我可以使用2元组作为默认值来实现这一点

>>> d=defaultdict(lambda:1)
>>> d[1]
1
>>> d['foo']
1

---

在算法上无法与之区分，但不知何故，生成器表达式令我满意

from collections import defaultdict

def merge_dictionaries_with_weight(all_dictionaries):
    totals = defaultdict(int)
    result = defaultdict(int)
    for each in all_dictionaries:
        weight = float(each['weight'])
        for key, value in each['data'].items():
            totals[key] += weight
            result[key] += weight * value
    for key, total in totals.items():
       result[key] /= total
    return result

---

+1我会把

d['weight']

吊到圈外，但在其他方面都很完美。@hughdbrown，我就是为了你才这么做的。哇，这真是不可思议的蟒蛇。你能解释一下lambda是干什么的吗？谢谢@TIMEX，我补充了一些解释

>>> d=defaultdict(lambda:(0,0))
>>> d[1]
(0, 0)
>>> d['foo']
(0, 0)

from collections import defaultdict

def merge_dictionaries_with_weight(all_dictionaries):
    totals = defaultdict(int)
    result = defaultdict(int)
    for each in all_dictionaries:
        weight = float(each['weight'])
        for key, value in each['data'].items():
            totals[key] += weight
            result[key] += weight * value
    for key, total in totals.items():
       result[key] /= total
    return result

>>> from collections import defaultdict
>>> weights, values = defaultdict(int), defaultdict(int)
>>> key_weight_value = ((key, d['weight'], value) 
                        for d in all_dictionaries 
                        for key, value in d['data'].iteritems())
>>> for k, w, v in key_weight_value:
...     weights[k], values[k] = weights[k] + w, values[k] + w * v
... 

>>> dict((k, values[k] * 1.0 / weights[k]) for k in weights)
{'apples': 5.0, 'oranges': 7.0, 'bananas': 3.0}