Question

我有这个dictionary (key,list)

index={'chair':['one','two','two','two'],'table':['two','three','three']}

我想要这个

#1. number of times each value occurs in each key. ordered descending
indexCalc={'chair':{'two':3,'one':1}, 'table':{'three':2,'two':1}}
#2. value for maximum amount for each key
indexMax={'chair':3,'table':2}
#3. we divide each value in #1 by value in #2 
indexCalcMax={'chair':{'two':3/3,'one':1/3}, 'table':{'three':2/2,'two':1/2}}

我认为我应该使用lambda表达式，但是我无法提出任何想法。有帮助吗？

Answer 1

首先，将值正确定义为列表：

index = {'chair': ['one','two','two','two'], 'table': ['two','three','three']}

然后将collections.Counter用于字典理解：

from collections import Counter

每个键中每个值出现的次数。

res1 = {k: Counter(v) for k, v in index.items()}

每个键的最大金额值

res2 = {k: v.most_common()[0][1] for k, v in res1.items()}

我们将＃1中的每个值除以＃2中的值

res3 = {k: {m: n / res2[k] for m, n in v.items()} for k, v in res1.items()}

Answer 2

index={'chair':{'one','two','two','two'},'table':{'two','three','three'}}

问题：{}正在创建集合。因此，您应该考虑将其转换为列表。

现在进入您的解决方案：

from collections  import Counter


index={'chair': ['one','two','two','two'],'table':['two','three','three']}
updated_index = {'chair': dict(Counter(index['chair'])), 'table': dict(Counter(index['table']))}
updated_index_2 = {'chair': Counter(index['chair']).most_common()[0][1], 'table': Counter(index['table']).most_common()[0][1]}
print(updated_index)
print(updated_index_2)

您可以使用python集合库Counter来查找计数，而无需编写任何lambda函数。

{'椅子'：{'一个'：1，'两个'：3}，'桌子'：{'两个'：1，'三个'：2}}

{'椅子'：3，'桌子'：2}

Answer 3

首先，您在创建index字典的方式上存在错误。您应该具有列表作为每个字典的元素，并且当前具有集合。集合会自动进行重复数据删除，因此您将无法从那里获得正确的计数。

您应将索引更正为：

index={'chair':['one','two','two','two'],'table':['two','three','three']}

您可以使用Python 3中的Counter module（它是dict模块的子类）来为indexCalc中的每个条目生成所需的内容。计数器会创建一个带有键的字典，以及键在集合中的存在次数。

indexCalc = {k, Counter(v) for k, v in index}

indexCalc看起来像这样：

{'chair': Counter({'two': 3, 'one': 1}), 'table': Counter({'three': 2, 'two': 1})}

我们可以轻松地找到与每个子词典中的最大值对应的索引：

indexMax = {k: max(indexCalc[k].values()) for k in indexCalc}

indexMax看起来像这样：

{'chair': 3, 'table': 2}

您可以通过以下理解来创建indexCalcMax，这有点难看：

indexCalcMax = {k: {val: indexCalc[k][val] / indexMax[k] for val in indexCalc[k]} for k in indexCalc}

是此循环的字典理解翻译：

for k in indexCalc:
  tmp = {}
  for val in indexCalc[k]:
    tmp[val] = indexCalc[k][val] / float(indexMax[k])
  indexCalcMax[k] = tmp

Answer 4

我知道这不是最理想的，但是我必须做为思考练习：

indexCalc = {
    k: {key: len([el for el in index[k] if el == key]) for key in set(index[k])} 
    for k in index
}

不是完全建议的lambda，而是理解...不要在生产中使用此代码：）这个答案只是部分的，您可以使用类比并提出所需的其他两个结构。

计算不同的字典值

4 个答案: