当我尝试根据另一个嵌套列表对嵌套列表进行排序时，如何解决此错误？

Question

I tried to base my solutions on other questions asked here but they dont quite work.

I have a nested list:

s = [[[921, 640], [4007, 49], [4821, 40]],
     [[1270, 20], [1943, 393], [4821, 183]],
     [[1300, 95], [857, 641], [4821, 83]]]

I want to sort the values at index 0 in the nested based on the values of another nested list. The other list looks like this:

i = [[921, 4281, 4007], [1943, 1270, 4821], [4821, 1300, 857]]

As you can see the values of the sublists in i align with values at index 0 in the sublists of s , but they are not same order. Now I want to order the values in s based on the values in i like this:

s_new = [[[921, 640],[4821, 40], [4007, 49]],
        [[1943, 393],[1270, 20], [4821, 183]],
        [[4821, 83],[1300, 95], [857, 641]]]

I tried this code based other questions with similar answers:

s_new = [(sorted(x, key=lambda item: i.index(item[0]))) for x in s]

But I get the error:

ValueError: 921 is not in list

What am I doing wrong and why am I getting this error?

I asked this question yesterday but it got marked as duplicate. However the linked questions and answers couldn't solve my problem.

Answer 1

You are missing a nested level, you can do this:

s = [[[921, 640], [4007, 49], [4821, 40]],
     [[1270, 20], [1943, 393], [4821, 183]],
     [[1300, 95], [857, 641], [4821, 83]]]

i = [[921, 4821, 4007], [1943, 1270, 4821], [4821, 1300, 857]]

s_new = [(sorted(x, key=lambda item: i[j].index(item[0]))) for j, x in enumerate(s)]

for x in s_new:
    print(x) 

Output

[[921, 640], [4821, 40], [4007, 49]]
[[1943, 393], [1270, 20], [4821, 183]]
[[4821, 83], [1300, 95], [857, 641]]

Also note that the i from your example is 4821 instead of 4281 . As an alternative you could iterate in parallel over the two list using zip:

s_new = [sorted(si, key=lambda x: ij.index(x[0])) for si, ij in zip(s, i)]

The two approaches above are O(n*n) due to the index call, for longer list is better to use a lookup dictionary, for example:

def sort(ls, order):
    priority = {k: p for p, k in enumerate(order)}
    return sorted(ls, key=lambda x: priority[x[0]])


s_new = [sort(si, ij) for si, ij in zip(s, i)]

Using a dictionary makes it O(n log n) that is the cost of a standard sorting algorithm.