这是一个老问题，但我看到的一些答案实际上并不能工作，因为zip是不可编写脚本的。其他答案没有费心导入operator，并在这里提供关于这个模块及其好处的更多信息。

对于这个问题，至少有两个好的习语。从您提供的示例输入开始:

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

使用“装饰-排序-取消装饰”成语

这也被称为schwartzan_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的第二项，依此类推。这可能会创建不稳定的输出，除非您包含字典顺序的原始列表索引，以保持副本的原始顺序。

使用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')

你可以创建一个pandas Series，使用主列表作为数据，另一个列表作为索引，然后根据索引进行排序:

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]

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()获得。

另外，如果你不介意使用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/

把两个列表压缩在一起，排序，然后取你想要的部分:

>>> 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))]

这是一个老问题，但我看到的一些答案实际上并不能工作，因为zip是不可编写脚本的。其他答案没有费心导入operator，并在这里提供关于这个模块及其好处的更多信息。

对于这个问题，至少有两个好的习语。从您提供的示例输入开始:

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

使用“装饰-排序-取消装饰”成语

这也被称为schwartzan_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的第二项，依此类推。这可能会创建不稳定的输出，除非您包含字典顺序的原始列表索引，以保持副本的原始顺序。

使用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')