Сортировка списка на основе значений из другого списка?

Question

У меня есть список таких строк:

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

Какой самый короткий способ сортировки X с использованием значений из Y, чтобы получить следующий вывод?

["a", "d", "h", "b", "c", "e", "i", "f", "g"]

Порядок элементов, имеющих один и тот же «ключ», не имеет значения. Я могу прибегнуть к использованию for конструкций, но мне любопытно, если есть более короткий путь. Есть предложения?

Answer 1

Кратчайший код

[x for _,x in sorted(zip(Y,X))]

Пример:

X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

Z = [x for _,x in sorted(zip(Y,X))]
print(Z)  # ["a", "d", "h", "b", "c", "e", "i", "f", "g"]

---

Вообще говоря

[x for _, x in sorted(zip(Y,X), key=lambda pair: pair[0])]

Разъяснения:

1. zip два list с.
2. создать новый, отсортированный list на основе zip, используя sorted().
3. с использованием понимания списка извлечение первых элементов каждой пары из отсортированного, сжатого list.

Для получения дополнительной информации о том, как установить \ использовать параметр key, а также функцию sorted в целом, посмотрите this .

---

Answer 2

Объедините два списка в один, рассортируйте его, затем возьмите нужные части:

>>> yx = zip(Y, X)
>>> yx
[(0, 'a'), (1, 'b'), (1, 'c'), (0, 'd'), (1, 'e'), (2, 'f'), (2, 'g'), (0, 'h'), (1, 'i')]
>>> yx.sort()
>>> yx
[(0, 'a'), (0, 'd'), (0, 'h'), (1, 'b'), (1, 'c'), (1, 'e'), (1, 'i'), (2, 'f'), (2, 'g')]
>>> x_sorted = [x for y, x in yx]
>>> x_sorted
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']

Объедините их вместе, чтобы получить:

[x for y, x in sorted(zip(Y, X))]

Answer 3

Кроме того, если вы не возражаете против использования numpy-массивов (или фактически уже имеете дело с numpy-массивами ...), вот еще одно приятное решение:

people = ['Jim', 'Pam', 'Micheal', 'Dwight']
ages = [27, 25, 4, 9]

import numpy
people = numpy.array(people)
ages = numpy.array(ages)
inds = ages.argsort()
sortedPeople = people[inds]

Я нашел его здесь: http://scienceoss.com/sort-one-list-by-another-list/

Answer 4

Самым очевидным решением для меня является использование ключевого слова key arg.

>>> X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
>>> Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]
>>> keydict = dict(zip(X, Y))
>>> X.sort(key=keydict.get)
>>> X
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']

Обратите внимание, что вы можете сократить это до одной строки, если вы хотите:

>>> X.sort(key=dict(zip(X, Y)).get)

Answer 5

Мне нравится иметь список отсортированных индексов.Таким образом, я могу отсортировать любой список в том же порядке, что и список источников.Когда у вас есть список отсортированных индексов, простое понимание списка сделает свое дело:

    X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
    Y = [ 0,   1,   1,    0,   1,   2,   2,   0,   1]

    sorted_y_idx_list = sorted(range(len(Y)),key=lambda x:Y[x])
    Xs = [X[i] for i in sorted_y_idx_list ]

    print( "Xs:", Xs )
    # prints: Xs: ["a", "d", "h", "b", "c", "e", "i", "f", "g"]

Обратите внимание, что список отсортированных индексов также можно получить с помощью numpy argsort ().

Answer 6

Еще одна альтернатива, объединяющая несколько ответов.

zip(*sorted(zip(Y,X)))[1]

Для работы на python3:

list(zip(*sorted(zip(B,A))))[1]

Answer 7

more_itertools имеет инструмент для параллельной сортировки итераций:

from more_itertools import sort_together


sort_together([Y, X])[1]
# ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')

Answer 8

Я действительно пришел сюда, чтобы отсортировать список по списку, в котором значения совпадают.

list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']

Answer 9

zip, сортировка по второму столбцу, возврат первого столбца.

zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]

Answer 10

Быстрая однострочная.

list_a = [5,4,3,2,1]
list_b = [1,1.5,1.75,2,3,3.5,3.75,4,5]

Скажем, вы хотите, чтобы список a соответствовал списку b.

orderedList =  sorted(list_a, key=lambda x: list_b.index(x))

Это полезно, когда нужно упорядочить меньший список со значениями в большем. Предполагая, что большой список содержит все значения в меньшем списке, это можно сделать.