根据另一个列表中的值对列表进行排序？

我有一个这样的字符串列表：

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结构的使用，但我好奇是否有更短的方法。有什么建议么？

最短代码

[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。

将两个列表压缩在一起，对其进行排序，然后选择所需的部分：

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

我实际上是来这里寻找按值匹配的列表对列表进行排序的。

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

more_itertools 有一个用于并行迭代可迭代对象的工具：

给定

from more_itertools import sort_together


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

演示版

sort_together([Y, X])[1]
# ('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()。

另一个选择，结合几个答案。

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

为了使用python3：

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

zip，按第二列排序，返回第一列。

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

快速的单线。

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

当需要将较小的列表排序为较大的值时，这将很有帮助。假设较大的列表包含较小列表中的所有值，则可以完成此操作。

您可以创建一个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']

如果您想同时获得两个排序列表（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是元组即可。如果有更好的方法，我也在徘徊。

警告：如果使用空列表运行它，则会崩溃。

我创建了一个更通用的函数，该函数根据@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

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)

这是一个古老的问题，但是我看到的一些答案由于zip无法编写脚本而无法实际使用。其他答案没有困扰import operator并在此处提供有关此模块及其好处的更多信息。

这个问题至少有两个好的习惯用法。从您提供的示例输入开始：

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

使用“ 装饰-排序-未装饰 ”习惯用法

在R. Schwartz在90年代在Perl中推广了这种模式之后，这也称为Schwartzian_transform：

# 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')