Making an ordered list from a list of dictionaries by custom rules in python

Question

Edited: I need to change the rule. I have a list of dictionaries like this:

A=[{0:[(0,0,2,1),(0,1,2,1)]},{1:(0,1,1,3)},{2:[(1,2,2,2)]},{3:(0,0,1,4),(0,1,1,4),(1,0,1,4)}]

First, I need to count the number of elements in each dictionary. Second, calculate multiply the last two elements for one of the elements in each list(because at each list the last two elements are the same), like this:

M=[(0,2,2) ,(1,3,1) , (2,4,1) , (3,4,3)]

the first element is the key, the second is the multiply of the last two elements, and the third is the number of elements in that list. (I don't need to print this part) then for each list calculate multiply/options, like this:

B=[(0,2/2), (1,3/1), (2,4/1), (3,4/3)]

I need the output to be a list of keys with the large to small the second element:

output: [2, 1, 3, 0]

Does anyone have any idea that could help?

Answer 1

New Solution as per edit

t=[{0:[(0,0,2,1),(0,1,2,1)]},{1:[(0,1,1,3)]},{2:[(1,2,2,2)]},{3:[(0,0,1,4),(0,1,1,4),(1,0,1,4)]}]

step_one=[]

for i in t:
    key_list=list(i.keys())
    value_list=list(i.values())
    first=key_list[0]
    second=value_list[0][0][-1]*value_list[0][0][-2]
    third=len(value_list[0])
    step_one.append((first,second,third))

print(step_one) # [(0, 2, 2), (1, 3, 1), (2, 4, 1), (3, 4, 3)]

step_two=[(i,j/k) for i,j,k in step_one]

step_three=[i for i,j in sorted(step_two,key=lambda x:-x[1])]

print(step_three) # [2, 1, 0, 3]

Will this work? Use the key parameter to perform your sort

t=[{0:[(0,0,1,3),(0,1,1,3)]},{1:[(0,1,1,3)]},{3:[(0,0,1,3),(0,1,1,3),(1,0,4,1)]}]
sorted_t=sorted(t,key=lambda x:len(list(x.values())[0]))
result=[list(i.keys())[0] for i in sorted_t]
print(result) # [1, 0, 3]

Breakdown

sorted_t=sorted(t,key=lambda x:len(list(x.values())[0]))

this will sort the list based on "length of first value in the dict" for each element

Result : [{1: [(0, 1, 1, 3)]}, {0: [(0, 0, 1, 3), (0, 1, 1, 3)]}, {3: [(0, 0, 1, 3), (0, 1, 1, 3), (1, 0, 4, 1)]}]

Then iterate through sorted_t and get the "key for each dict in the sorted list", [0] is for indexing the element from the "key list". Otherwise you will end with a list like [[1], [0], [3]]

Answer 2

If your dictionaries are going to have more than one key then you can utilize this method

from collections import defaultdict

A = [{0: [(0, 0, 1, 3), (0, 1, 1, 3)], 2: [(0, 1, 0, 3)]},
     {1: [(0, 1, 1, 3)], 4: [(0, 1, 3, 3), (1, 1, 1, 2), (1, 1, 4, 1)]},
     {3: [(0, 0, 1, 3), (0, 1, 1, 3), (1, 0, 4, 1)]}
]
dd = defaultdict(list)

for dictionary in A:
    for k, v in dictionary.items():
        dd[len(v)].append(k)

result = [k[1] for k in sorted(dd.items(), key=lambda x: x[0])]
print(result)

Outputs:

[[2, 1], [0], [4, 3]]

Answer 3

@python_learner and @woblob beat me to it, and I very much approve of their answers. However, I just wanted to add the an alternative (yet similar) approach which let's you access the the list of tuples after finding the ranks.

By ending up with a list of keys, sorted by their rank, i.e. [1,0,3] you've lost the information of where the list of tuples are.

To recover the list of tuples, you would need to iterate over A again and search for the keys, but that could be problematic if A contains multiple dicts using the same key.

Hence, the following approach conserves the index_of_A for which each key with some rank is found within A.

# I've added missing brackets in the element of A, {3:[..]}
A=[{0:[(0,0,1,3),(0,1,1,3)]},{1:[(0,1,1,3)]},{3:[(0,0,1,3),(0,1,1,3),(1,0,4,1)]}]

# A is a list of dicts
# Each dict has only one (numerical) key,
# -> resolving to a list of tuples

# run over A and create a new Rank dict, where keys are
# the keys from the dicts in A, and values are tuples of
# the ranks and and index in A for which to locate the lists again.
ranks = {}
for index_of_A, dictionary in enumerate(A):
  for key, list_of_tuples in dictionary.items():
    ranks[key] = (len(list_of_tuples), index_of_A)


# https://stackoverflow.com/questions/613183/how-do-i-sort-a-dictionary-by-value
sorted_ranks = {k: v for k, v in sorted(ranks.items(), key=lambda item: item[1])}


# Get Ranks, key and the list of tuples, and perform some work on them..
for key_of_A, (rank, index_of_A) in sorted_ranks.items():
  print("Do some work on: Rank %d | Key %d | List %s" % (rank, key_of_A, str(A[index_of_A])))
  do_some_work(index_of_A)


# The Keys sorted by their ranks
print ("keys sorted by rank: " + str([key for key in sorted_ranks]))

Output:

Rank 1 | Key 1 | List {1: [(0, 1, 1, 3)]}
Rank 2 | Key 0 | List {0: [(0, 0, 1, 3), (0, 1, 1, 3)]}
Rank 3 | Key 3 | List {3: [(0, 0, 1, 3), (0, 1, 1, 3), (1, 0, 4, 1)]}

keys sorted by rank: [1, 0, 3]

EDIT: it is requested in the comments to show how to do some work on the data, so I've added the function below, and added a call to it in the work loop above.

# Added a function for doing some work as requesed in comments
def do_some_work(index_of_A):
  # A is a global variable
  a_dict = A.pop(index_of_A)
  # do whatever with the data ..