基于另一个较短列表的列表排序

Question

I need to sort a list based on the order of the elements in another list which is shorter ie, doesn't have all the elements compared to the list I'm sorting. I run into this error when using the sort(key=short_list) :

long_list = ['y', 'z', 'x', 'c', 'a', 'b']
short_list = ['b', 'c', 'a']
long_list.sort(key=short_list.index)

ValueError: 'x' is not in list

Is there another way to sort the long_list to result in a list that maintains the order of short_list followed by the order of the elements in the long_list ?

['b', 'c', 'a', 'y', 'z', 'x']

Answer 1

Something like this should work:

def position(value):
    try:
        return short_list.index(value)
    except ValueError:
        return len(short_list)

long_list.sort(key=position)

Sorting is guaranteed to be stable , so using len(short_list) ensures that the unknown values sort last.

Answer 2

You can use in to detect if the element is in the short_list and a ternary to return a tuple based on that.:

>>> long_list = ['y', 'z', 'x', 'c', 'a', 'b']
>>> short_list = ['b', 'c', 'a']
>>> sorted(long_list, key=lambda e: (short_list.index(e),e) if e in short_list  else (len(short_list),e))
['b', 'c', 'a', 'x', 'y', 'z']

Since Python sorts are stable, the order will only change based on a change of the elements themselves. To make that change, we can use a tuple with either a (index_of_the_element, element) of (len(short_list), element) to effect that change.

If you want the elements to not change order if the element is not in short list, just return an empty tuple:

>>> sorted(long_list, key=lambda e: (short_list.index(e),e) if e in short_list  else (len(short_list),))
['b', 'c', 'a', 'y', 'z', 'x']

Answer 3

I would search in the short list first and in the long list if necessary:

>>> def index(list1, list2):
...  def inner(value):
...   try:
...    return list1.index(value)
...   except ValueError:
...    return list2.index(value)
... 
>>> long_list = ['x', 'y', 'z', 'a', 'b', 'c']
>>> short_list = ['a', 'b', 'c']
>>> long_list.sort(key=index(short_list, long_list))
>>> long_list
['a', 'b', 'c', 'x', 'y', 'z']

Edit: as florian-weimer pointed out , this solution does not always work. Joining the two solutions:

>>> def index(list1, list2):
...  def inner(value, l=len(list1)):
...   try:
...    return list1.index(value)
...   except ValueError:
...    return l
...  return inner
... 
>>> long_list = ['x', 'y', 'z', 'a', 'b', 'c']
>>> short_list = ['a', 'b', 'c', 'y']
>>> sorted(long_list, key=index(short_list, long_list))
['a', 'b', 'c', 'y', 'x', 'z']
>>> 

Answer 4

Basically, what i'm doing here is i am first sorting elements of long_list by their index in short_list. If the element is not in short_list, I'll assign them all the same value of len(short_list). While sorting, if the first_sort is the same for two elements, it'll sort by second_sort which is the position in the long_list. lets look at each case

1. 'a', 'b' and 'c' are all sorted by their position in short_list. If there are repetitions of 'a', 'b' or 'c' in long_list, then they are sorted by their respective positions. So you'll get ['b', 'c', 'c', 'a', 'a', 'a'].
2. 'y', 'z', 'x' get sorted first by len(short_list). This puts them last compared to the elements in the short list. Then they get sorted in the order they come in long_list.

Key takeaways:

1. You can pass a function to key that will let you sort according to any function.
2. You can pass a function that returns multiple values, so that any ties in the first value are resolved by the second value and so on.

long_list = ['y', 'z', 'x', 'c', 'a', 'b']
short_list = ['b', 'c', 'a']

def sorter(x):
    if x in short_list:
        first_sort = short_list.index(x)
    else:
        first_sort = len(short_list)
    second_sort = long_list.index(x)
    return first_sort, second_sort

print(sorted(long_list, key=sorter)) 

['b', 'c', 'a', 'y', 'z', 'x']