根据另一个列表中的值对列表进行排序
Posted
技术标签:
【中文标题】根据另一个列表中的值对列表进行排序【英文标题】：Sorting list based on values from another list 【发布时间】：2011-09-30 21:40:34 【问题描述】：我有一个这样的字符串列表：
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 构造，但我很好奇是否有更短的方法。有什么建议吗？
【问题讨论】：
在绘制数据时，riza 的答案可能很有用，因为 zip(*sorted(zip(X, Y), key=lambda pair: pair[0])) 返回排序后的 X 和 Y用 X 的值排序。 More general case (sort list Y by any key instead of the default order) 【参考方案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])]
解释：
zip 两个lists。
使用sorted()基于zip创建一个新的排序list。
使用列表推导提取从已排序、压缩的list 中每对的第一个元素。
有关如何设置\使用key 参数以及一般sorted 函数的更多信息，请查看this。
【讨论】：
这是正确的，但我会补充一点，如果您尝试按同一个数组对多个数组进行排序，这不一定会按预期工作，因为正在使用的密钥排序是（y，x），而不仅仅是y。你应该使用 [x for (y,x) in sorted(zip(Y,X), key=lambda pair: pair[0])] 很好的解决方案！但它应该是：列表是关于对的第一个元素进行排序的，并且理解提取对的“第二个”元素。 这个解决方案在存储方面很差。尽可能首选就地排序。 @Hatefiend 很有趣，你能指出如何实现这一目标的参考吗？ @RichieV 我建议使用快速排序或就地合并排序实现。一旦你有了它，定义你自己的比较函数，它根据列表Y 的索引比较值。最终结果应该是列表 Y 保持不变，列表 X 被更改为预期的解决方案，而无需创建临时列表。【参考方案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))]
【讨论】：
如果X 是str 的列表，这很好，但如果< 可能没有为X 中的某些项目对定义，请小心，例如 -如果其中一些是None
当我们尝试对 zip 对象使用排序时，AttributeError: 'zip' object has no attribute 'sort' 是我现在得到的。
您使用的是 Python 3。在 Python 2 中，zip 生成了一个列表。现在它产生了一个可迭代的对象。 sorted(zip(...)) 应该仍然可以工作，或者：them = list(zip(...)); them.sort()【参考方案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/
【讨论】：
对于更大的数组/向量，这个带有 numpy 的解决方案是有益的！ 如果它们已经是 numpy 数组，那么它就是sortedArray1= array1[array2.argsort()]。这也使得通过二维数组的特定列对多个列表进行排序变得容易：例如sortedArray1= array1[array2[:,2].argsort()] 按array2 第三列中的值对array1（可能有多个列）进行排序。【参考方案4】：
对我来说最明显的解决方案是使用 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)
正如 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 描述的 decorate-sort-undecorate 方法稍微简单一些并且适用于所有情况，因此大多数情况下它可能会更好。 （这是一个非常古老的答案！）
【讨论】：
这是否要求 X 中的值是唯一的？【参考方案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')
【讨论】：
我喜欢这个，因为我可以用一个索引做多个列表sort_together([Index,X,Y,Z])
哦，忽略，我也可以做 sorted(zip(Index,X,Y,Z))。【参考方案6】：
我实际上是想通过值匹配的列表对列表进行排序。
list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']
【讨论】：
这是个坏主意。index 将对 list_a 执行 O(N) 搜索，从而得到 O(N² log N) 排序。
@Richard：键在排序前计算一次；所以复杂度实际上是 O(N^2)。
@Stef 是的，但仍然是个坏主意。【参考方案7】：
另一种选择，结合几个答案。
zip(*sorted(zip(Y,X)))[1]
为了适用于 python3：
list(zip(*sorted(zip(B,A))))[1]
【讨论】：
【参考方案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()获取。
【讨论】：
您知道是否有一种方法可以通过一个排序索引列表一次对多个列表进行排序？像这样的东西？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 ]【参考方案9】：
zip，按第二列排序，返回第一列。
zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]
【讨论】：
注意：key=operator.itemgetter(1) 解决了重复问题 zip 不可下标...您必须实际使用list(zip(*sorted(zip(X,Y), key=operator.itemgetter(1))))[0]
@Keith 什么重复问题？
如果有多个匹配，则获得第一个【参考方案10】：
这是一个老问题，但我看到的一些答案实际上并不起作用，因为zip 不可编写脚本。其他答案没有打扰import operator，并在此处提供有关此模块及其优势的更多信息。
对于这个问题，至少有两个好的习语。从您提供的示例输入开始：
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1 ]
使用“Decorate-Sort-Undecorate”成语
这也被称为Schwartzian_transformR. 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')
【讨论】：
我认为在大多数情况下我会使用lambda x: x[1] 而不是operator.itemgetter(1)，因为它更容易理解并且不需要额外的包。使用operator.itemgetter 有优势吗？【参考方案11】：
您可以创建一个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']
【讨论】：
【参考方案12】：一个快速的单线。
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))
当需要将较小的列表排序为较大的值时，这很有帮助。假设较大的列表包含较小列表中的所有值，则可以这样做。
【讨论】：
这并不能解决 OP 的问题。您是否使用示例列表X 和 Y 尝试过？
这是个坏主意。 index 将对 list_b 执行 O(N) 搜索，从而得到 O(N² log N) 排序。【参考方案13】：
受@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
【讨论】：
【参考方案14】：如果您想获得两个排序列表 (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 是元组。 如果有更好的方法，我也在徘徊。
警告：如果您使用空列表运行它会崩溃。
【讨论】：
【参考方案15】：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)))
【讨论】：
上一个答案是使用来自A 的值对B 进行排序。这是正确的，但具有误导性。我修好了，谢谢提醒。【参考方案16】：
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)
使用cur_loclist 跟踪list2 中的索引位置
[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)
【讨论】：
以上是关于根据另一个列表中的值对列表进行排序的主要内容，如果未能解决你的问题，请参考以下文章
按对象属性之一的值对对象列表进行排序，其中只有一个值是感兴趣的