计算不同的字典值

Question

I have this dictionary (key,list)

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

and i want this

#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}}

I think I should use lambda expressions, but can't come up with any idea how i can do that. Any help?

Answer 1

First, define your values as lists correctly:

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

Then use collections.Counter with dictionary comprehensions:

from collections import Counter

1. number of times each value occurs in each key.

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

2. value for maximum amount for each key

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

3. we divide each value in #1 by value in #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'}}

Problem: {} is creating a set. So you should consider to convert it into list.

Now coming to your solution:

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)

You can use python collections library, Counter to find the count without writing any lambda function.

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

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

Answer 3

Firstly, you have a mistake in how you created the index dict. You should have lists as the elements for each dictionary, you currently have sets. Sets are automatically deduplicated, so you will not be able to get a proper count from there.

You should correct index to be:

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

You can use the Counter module in Python 3, which is a subclass of the dict module, to generate what you want for each entry in indexCalc . A counter will create a dictionary with a key, and the number of times that key exists in a collection.

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

indexCalc looks like this:

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

We can easily find the index that corresponds to the maximum value in each sub-dictionary:

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

indexMax looks like this:

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

You can create indexCalcMax with the following comprehension, which is a little ugly:

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

which is a dict-comprehension translation of this loop:

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

Answer 4

I know this is suboptimal, but I had to do it as a thought exercise:

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

Not exactly lambda, as suggested, but comprehensions... Don't use this code in production :) This answer is only partial, you can use the analogy and come up with the other two structures that you require.