如何创建具有某些特定值的行为的字典

Question

Suppose I have two lists:

l1 = [['b', (1, 1)], ['b', (1, 2)], ['b', (1, 3)], ['a', (1, 5)],
      ['b', (2, 1)], ['b',(3, 1)]]

l2 = ['A','B','C']

How can I create a dictionary into this format?

dct = {'A': len(sublist1), 'B': len(sublist2), 'C' : len(sublist3)}

where

sublist1 = [['b', (1, 1)], ['b', (1, 2)], ['b', (1, 3)], ['a', (1, 5)]]
sublist2 = [['b', (2, 1)]]
sublist3 = [['b',(3, 1)]]

what will happen if my l1 is as given below:

ls1 = [[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2)]]    

then my output should be:

dct = {'A': len(sublist1), 'B': len(sublist2)}

where

sublist1 = [[(1, 1),(1, 2),(1, 3),(1, 4)]]
sublist2 = [[(2, 1),(2, 2),(2, 3)]]

Can the overall problem can be solved in generic way?

Answer 1

This seems to work:

from itertools import groupby

key = lambda x: x[1][0]
lens = [len(list(g)) for k, g in groupby(sorted(l1, key=key), key=key)]
dct = dict(zip(l2, lens))

I hope I've inferred correctly when I've assumed A match with 1, B with 2, and so on.

Re: OP edit

I don't know where the (2, 3) item in your sublist2 comes from, I assume it's a mistake. Also, I assume the single element list ls1 was in fact meant to be the direct container of the tuples, since using nested lists here serves no purpose. If so, here's my proposal for a generic solution:

from itertools import groupby
from string import ascii_uppercase

key = lambda x: x[0]
lens = [len(list(g)) for k, g in groupby(sorted(l1, key=key), key=key)]
dct = dict(zip(ascii_uppercase, lens))

So, no big changes. The zip function will, when given arguments of unequal length, return a list with the same length as the shortest argument, and this behaviour suits us fine in this situation.

Keep in mind that if there are more than 26 different values of the first tuple element, then this solution will break, and simply disregard any values larger than the 26th.

Answer 2

groups = itertools.groupby(l1, lambda x: x[1][0])
dict(zip(l2, map(len, (list(list(g[1]) for g in groups)))))

results in

{'A': 4, 'B': 1, 'C': 1}

Answer 3

>>> l1 = [['b', (1, 1)], ['b', (1, 2)], ['b', (1, 3)], ['a', (1, 5)], ['b', (2,
1)], ['b',(3, 1)]]
>>> dct = {'A': 0, 'B' : 0, 'C': 0}
>>> translation = {1: 'A', 2: 'B', 3: 'C'}
>>> for list_ in l1:
...     letter, tuple_ = list_
...     num1, num2 = tuple_
...     t = translation[num1]
...     dct[t] += 1
...
>>> dct
{'A': 4, 'C': 1, 'B': 1}

Answer 4

from collections import defaultdict

lst = [['b', (1, 1)], 
       ['b', (1, 2)],
       ['b', (1, 3)],
       ['a', (1, 5)],
       ['b', (2, 1)],
       ['b', (3, 1)]]  #test list

def mapping(x):
    """ convert 1 to A, 2 to B and so on """
    return chr(ord('A')+x-1)

dct = defaultdict(int)

for _, tple in lst:
    k, _ = tple
    dct[ mapping(k) ] += 1

print (dct) # defaultdict(<type 'int'>, {'A': 4, 'C': 1, 'B': 1})

Answer 5

I would have done this :

dct = dict((k, len([l for l in l1 if l[1][0] == i + 1]))
           for i, k in enumerate(l2))