Сортировка списка на основе значений из другого списка?
У меня есть список строк, как это:
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 конструкции, но мне любопытно, если есть более короткий путь. Какие-либо предложения?
21 ответ
Кратчайший код
[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])]
Разъяснение:
zipдваlists.- создать новый, отсортированный
listна основеzipс помощьюsorted(), - используя понимание списка,извлеките первые элементы каждой пары из отсортированного, сжатого
list,
Для получения дополнительной информации о том, как установить \ использоватьkeyпараметр, а такжеsorted функция в целом, посмотрите на это.
Сожмите два списка вместе, рассортируйте их, затем возьмите нужные части:
>>> 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))]
Кроме того, если вы не возражаете против использования 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/
Наиболее очевидным решением для меня является использование 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)
more_itertools имеет инструмент для параллельной сортировки итераций:
from more_itertools import sort_together
sort_together([Y, X])[1]
# ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')
Я на самом деле пришел сюда, чтобы отсортировать список по списку, где значения совпадают.
list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']
Еще одна альтернатива, объединяющая несколько ответов.
zip(*sorted(zip(Y,X)))[1]
Чтобы работать на python3:
list(zip(*sorted(zip(B,A))))[1]
Мне нравится иметь список отсортированных индексов. Таким образом, я могу отсортировать любой список в том же порядке, что и список источников. Как только у вас есть список отсортированных индексов, простое понимание списка сделает свое дело:
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().
zip, сортировка по второму столбцу, возврат первого столбца.
zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]
Это старый вопрос, но некоторые ответы, которые я вижу, на самом деле не работают, потому что zipне скрипт. Остальные ответы не удосужилисьimport operator и предоставьте дополнительную информацию об этом модуле и его преимуществах здесь.
Для этой проблемы есть как минимум две хорошие идиомы. Начиная с предоставленного вами примера ввода:
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1 ]
Использование идиомы " украсить-сортировать-не украсить "
Это также известно как Schwartzian_transform в честь Р. Шварца, который популяризировал этот шаблон в Perl в 90-х:
# Zip (decorate), sort and unzip (undecorate).
# Converting to list to script the output and extract X
list(zip(*(sorted(zip(Y,X)))))[1]
# Results in: ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')
Обратите внимание, что в этом случае Y а также Xсортируются и сравниваются лексикографически. То есть первые предметы (отY) сравниваются; и если они совпадают, то вторые предметы (изX) сравниваются и т. д. Это может привести к нестабильным результатам, если вы не включите индексы исходного списка для лексикографического упорядочения, чтобы дубликаты оставались в их исходном порядке.
С использованием operator модуль
Это дает вам более прямой контроль над сортировкой ввода, поэтому вы можете добиться стабильности сортировки, просто указав конкретный ключ для сортировки. Смотрите больше примеров здесь.
import operator
# Sort by Y (1) and extract X [0]
list(zip(*sorted(zip(X,Y), key=operator.itemgetter(1))))[0]
# Results in: ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')
Большинство приведенных выше решений сложны, и я думаю, что они не будут работать, если списки имеют разную длину или не содержат одни и те же элементы. Решение ниже простое и не требует импорта.
list1 = ['B', 'A', 'C'] # Required sort order
list2 = ['C', 'B'] # Items to be sorted according to list1
result = list1
for item in list1:
if item not in list2: result.remove(item)
print(result)
Выход:
['B', 'C']
- Примечание. Любой элемент, не входящий в list1, будет проигнорирован, поскольку алгоритм не будет знать, какой порядок сортировки использовать.
Быстрый однострочник.
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))
Это полезно, когда нужно упорядочить меньший список со значениями в большем. Предполагая, что большой список содержит все значения в меньшем списке, это можно сделать.
Вот ответ Whatangs, если вы хотите получить оба отсортированных списков (python3).
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1]
Zx, Zy = zip(*[(x, y) for x, y in sorted(zip(Y, X))])
print(list(Zx)) # [0, 0, 0, 1, 1, 1, 1, 2, 2]
print(list(Zy)) # ['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']
Просто помните, что Zx и Zy - это кортежи. Я также брожу, если есть лучший способ сделать это.
Предупреждение: если вы запускаете его с пустыми списками, он вылетает.
Вы можете создать pandas Seriesиспользуя первичный список как data а другой список как index, а затем просто отсортировать по индексу:
import pandas as pd
pd.Series(data=X,index=Y).sort_index().tolist()
выход:
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1 ]
Вы можете сделать это одной строкой:
X, Y = zip(*sorted(zip(Y, X)))
Я создал более общую функцию, которая сортирует более двух списков на основе другого, вдохновленного ответом @Whatang.
def parallel_sort(*lists):
"""
Sorts the given lists, based on the first one.
:param lists: lists to be sorted
:return: a tuple containing the sorted lists
"""
# Create the initially empty lists to later store the sorted items
sorted_lists = tuple([] for _ in range(len(lists)))
# Unpack the lists, sort them, zip them and iterate over them
for t in sorted(zip(*lists)):
# list items are now sorted based on the first list
for i, item in enumerate(t): # for each item...
sorted_lists[i].append(item) # ...store it in the appropriate list
return sorted_lists
Я думаю, что большинство приведенных выше решений не будут работать, если 2 списка имеют разный размер или содержат разные элементы. Приведенное ниже решение простое и должно исправить эти проблемы:
import pandas as pd
list1 = ['B', 'A', 'C'] # Required sort order
list2 = ['C', 'A'] # Items to be sorted according to list1
result = pd.merge(pd.DataFrame(list1), pd.DataFrame(list2))
print(list(result[0]))
выход:
['A', 'C']
- Примечание. Любой элемент, не входящий в list1, будет проигнорирован, поскольку алгоритм не будет знать, какой порядок сортировки использовать.
Эта функция должна работать для массивов.
def sortBoth(x,y,reverse=False):
'''
Sort both x and y, according to x.
'''
xy_sorted=array(sorted(zip(x,y),reverse=reverse)).T
return xy_sorted[0],xy_sorted[1]
list1 = ['a','b','c','d','e','f','g','h','i']
list2 = [0,1,1,0,1,2,2,0,1]
output=[]
cur_loclist = []
Чтобы получить уникальные значения, присутствующие в list2
list_set = set(list2)
Найти местоположение индекса в list2
list_str = ''.join(str(s) for s in list2)
Расположение индекса в list2 отслеживается с помощью cur_loclist
[0, 3, 7, 1, 2, 4, 8, 5, 6]
for i in list_set:
cur_loc = list_str.find(str(i))
while cur_loc >= 0:
cur_loclist.append(cur_loc)
cur_loc = list_str.find(str(i),cur_loc+1)
print(cur_loclist)
for i in range(0,len(cur_loclist)):
output.append(list1[cur_loclist[i]])
print(output)
Для java то, что я получил с помощью сортировки выбора, таково:-
static void Sorting_list_based_on_values_from_another_list(){
String [] X = {"a", "b", "c", "d", "e", "f", "g", "h", "i" };
int [] Y = { 0, 1, 1, 0, 1, 2, 2, 0, 1 };
for(int i=0;i<=Y.length;i++){
for (int j=i;j<Y.length;j++){
if(Y[i]>Y[j]){
int n=Y[i];
Y[i] = Y[j];
Y[j] = n;
// swpping alphabets
String x=X[i];
X[i]=X[j];
X[j]=x;
}
}
}
for (int a:Y) {
System.out.print(a +" ");
}
System.out.println("");
for (String a:X) {
System.out.print(a+" ");
}
}
Я думаю, что название исходного вопроса неверно. Если у вас есть 2 списка с одинаковым количеством элементов и где каждый элемент в списке 1 связан со списком 2 в том же порядке (например, a = 0 , b = 1 и т. д.), то вопрос должен быть «Как отсортировать словарь ?», а не «Как отсортировать список на основе значений из другого списка?». Приведенное ниже решение является наиболее эффективным в этом случае:
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1 ]
dict1 = dict(zip(X,Y))
result = sorted(dict1, key=dict1.get)
print(result)
Результат:
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']