根据并行列表中的相应值对列表进行排序

Question

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

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

具有相同"key"的元素的顺序并不重要。我可以使用 for 循环来排序，但我想知道是否有更简单的方法。有什么建议吗？

- Legend

---

riza的答案在绘制数据时可能很有用，因为zip(*sorted(zip(X, Y), key=lambda pair: pair[0]))返回已按X值排序的X和Y。 - j-i-l

更一般的情况（按任意键对列表Y进行排序而不是默认顺序） - user202729

虽然这可能不明显，但这与 排序 Y 完全等效，并以与 Y 排序相同的方式重新排列 X。我将这两个问题都保存了相当长的时间，并为它们感到痛苦，因为似乎有些不太对劲 - 直到今天我意识到了重复（在处理其他问题以使其更清晰并改进标题后）。 - Karl Knechtel

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 两个列表。
2. 使用sorted()函数创建一个新的排序后的列表，基于zip。
3. 使用列表推导式从已排序、已合并的list中提取每对中的第一个元素。

如需了解如何设置/使用key参数以及sorted函数，请参阅此页面。

---

- Whatang

---

这是正确的，但我想补充一下，如果你试图按相同的数组对多个数组进行排序，这并不一定会按预期工作，因为用于排序的键是(y,x)，而不仅仅是y。相反，你应该使用[x for (y,x) in sorted(zip(Y,X), key=lambda pair: pair[0])]。 - gms7777

好的解决方案！但应该是：该列表根据对成对元素的第一个元素进行排序，而推导式提取成对元素的“第二个”元素。 - MasterControlProgram

@Hatefiend 很有趣，你能指出如何实现吗？ - RichieV

Z = [e[1] for e in sorted(zip(Y,X))] 这样写同样好用，而且至少对我来说更易于理解。 - pintergabor

“最短代码”方法在列表X包含对象时无效。应首先提供“一般情况下”的方法。供参考的较短的一般方法为：Z = sorted(X, key=lambda x: Y[X.index(x)])。 - user2585501

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

- Ned Batchelder

---

如果X是一个字符串列表，那么这很好，但是如果有可能存在某些X中的项目无法定义<运算符，例如-如果其中一些项目为None，则需要小心。请注意。 - John La Rooy

目前当我们尝试在zip对象上使用sort时，会得到AttributeError: 'zip' object has no attribute 'sort'的错误提示。 - Ash Upadhyay

您正在使用Python 3。在Python 2中，zip生成一个列表，而现在它生成一个可迭代对象。sorted(zip(...))仍然可以正常工作，或者：them = list(zip(...)); them.sort()。 - Ned Batchelder

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/

- Tom

---

对于更大的数组/向量，使用numpy的解决方案是有益的！ - MasterControlProgram

如果它们已经是numpy数组，那么简单地使用sortedArray1= array1[array2.argsort()]即可进行排序。这还可以通过一个2D数组的特定列轻松地对多个列表进行排序：例如，sortedArray1= array1[array2[:,2].argsort()]对array1（可能有多个列）按照array2第三列的值进行排序。 - Aaron Bramson

Answer 4

对我来说最明显的解决方案是使用key关键字参数。

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

正如Wenmin Mu和Jack Peng所指出的，这假设 X 中的值都是不同的。可以通过索引列表轻松处理：

>>> Z = ["A", "A", "C", "C", "C", "F", "G", "H", "I"]
>>> Z_index = list(range(len(Z)))
>>> Z_index.sort(key=keydict.get)
>>> Z = [Z[i] for i in Z_index]
>>> Z
['A', 'C', 'H', 'A', 'C', 'C', 'I', 'F', 'G']

由于从Whatang描述的装饰-排序-去装饰方法更简单且适用于所有情况，因此大多数情况下它可能更好。 （这是一个非常古老的答案！）

- senderle

---

需要求X中的数值是唯一的吗？ - Jack Peng

Answer 5

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

- pylang

---

我喜欢这个功能，因为我可以使用一个索引来处理多个列表sort_together([Index,X,Y,Z])。 - Tunneller

哦，算了，我也可以用sorted(zip(Index,X,Y,Z))。 - Tunneller

Answer 6

我实际上是来这里想要按照一个列表中的值匹配另一个列表并对其进行排序。

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

- nackjicholson

---

这是一个不好的想法。index将在list_a上执行_O(N)_搜索，导致_O(N² log N)_排序。 - Richard

@Richard：在排序之前，密钥只被计算一次；因此其复杂度实际上是O(N^2)。 - Stef

@Stef，没错，但这仍然是个坏主意。 - juanpa.arrivillaga

Answer 7

另一种选择是将几个答案结合起来。

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

为了让它适用于Python3：

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

- TMC

---

原文：https://dev59.com/PGw15IYBdhLWcg3wbbNx#6620187 - djvg

Answer 8

我喜欢有一个已排序的索引列表。这样，我可以按照源列表的顺序对任何列表进行排序。一旦你有了一个已排序的索引列表，一个简单的列表推导式就能搞定：

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

- 1-ijk

---

你知道是否有一种方法可以通过一个排序的索引列表同时对多个列表进行排序吗？类似这样的操作？`X1= ["a", "b", "c", "d", "e", "f", "g", "h", "i"] X2 = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]X1s, X2s = [X1[i], X2[i] for i in sorted_y_idx_list ]` - Jesse Kerr

Answer 9

压缩，按第二列排序，返回第一列。

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

- riza

---

注意：key=operator.itemgetter(1)解决了重复问题。 - Keith

zip 不可订阅... 你必须实际使用 list(zip(*sorted(zip(X,Y), key=operator.itemgetter(1))))[0]。 - raphael

@Keith 什么重复问题？ - Josh

如果有多个匹配项，则获取第一个。 - Keith

请参见 https://dev59.com/TnVD5IYBdhLWcg3wU56G 。 - djvg

Answer 10

这是一个老问题，但我看到的一些答案实际上并不起作用，因为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，在90年代由R. Schwartz在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模块

这使您更直接地控制如何对输入进行排序，因此您可以通过简单地声明要按其排序的特定键来获得排序稳定性。在这里查看更多示例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')

- Amelio Vazquez-Reina

---

我认为在大多数情况下，我会使用lambda x: x[1]而不是operator.itemgetter(1)，因为它更容易理解，而且不需要额外的包。使用operator.itemgetter有什么优势吗？ - Matthias Fripp