我有一个像这样的字符串列表：
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1]
使用Y中的值对X进行排序以获得以下输出的最短方法是什么？
["a", "d", "h", "b", "c", "e", "i", "f", "g"]
具有相同“键”的元素的顺序无关紧要。我可以使用for构造，但我很好奇是否有更短的方法。有什么建议吗？
答案 0 :(得分：351)
最短代码
[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 :(得分：94)
将两个列表压缩在一起，对其进行排序，然后获取所需的部分：
>>> 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))]
答案 2 :(得分：63)
另外，如果你不介意使用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/
答案 3 :(得分：30)
对我来说最明显的解决方案是使用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)
答案 4 :(得分：12)
我喜欢列出已排序的索引。这样，我可以按照与源列表相同的顺序对任何列表进行排序。一旦你有了一个排序索引列表，一个简单的列表理解就可以解决这个问题：
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（）来获取已排序的索引列表。
答案 5 :(得分：10)
另一种选择，结合了几个答案。
zip(*sorted(zip(Y,X)))[1]
为了使用python3：
list(zip(*sorted(zip(B,A))))[1]
答案 6 :(得分：4)
zip，按第二列排序，返回第一列。
zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]
答案 7 :(得分：4)
more_itertools有一个并行排序iterables的工具：
from more_itertools import sort_together
sort_together([Y, X])[1]
# ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')
答案 8 :(得分：4)
我实际上是来这里的，目的是按照值匹配的列表对列表进行排序。
list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']
答案 9 :(得分：2)
快速单行。
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))
当需要将较小的列表排序为较大的值时，这很有用。假设较大的列表包含较小列表中的所有值，则可以完成。
答案 10 :(得分：1)
您可以使用主要列表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']
答案 11 :(得分：1)
这是一个古老的问题，但是我看到的一些答案实际上无法正常工作，因为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之后，又被称为R. Schwartz，后者在90年代在Perl中推广了这种模式：
# 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），依此类推。除非您按字典顺序包括原始列表索引以使重复项保持原始顺序，否则这可以创建unstable输出。
operator module 这使您可以更直接地控制对输入进行排序的方式，因此您只需声明要排序的特定键即可获得sorting stability。查看更多示例here。
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')
答案 12 :(得分：1)
我创建了一个更通用的功能，根据@ 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
答案 13 :(得分：0)
如果你想获得两个排序列表（python3），这里是Whatangs的答案。
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是元组。 如果有更好的方法，我也会徘徊。
警告：如果您使用空列表运行它，则会崩溃。
答案 14 :(得分：0)
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)
答案 15 :(得分：0)
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)))
答案 16 :(得分：0)
对于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+" ");
}
}