问题：根据另一个列表中的值对列表进行排序？
我有一个这样的字符串列表：
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结构的使用，但我好奇是否有更短的方法。有什么建议么？
I have a list of strings like this:
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1 ]
What is the shortest way of sorting X using values from Y to get the following output?
["a", "d", "h", "b", "c", "e", "i", "f", "g"]
The order of the elements having the same “key” does not matter. I can resort to the use of for constructs but I am curious if there is a shorter way. Any suggestions?
回答 0
最短代码
[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两个list。- 创建一个新的，
list基于zip使用排序sorted()。
- 使用列表推导从排序的，压缩的中提取每对的第一个元素
list。
有关如何设置\使用key参数以及sorted一般功能的更多信息，请查看this。
Shortest Code
[x for _,x in sorted(zip(Y,X))]
Example:
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"]
Generally Speaking
[x for _, x in sorted(zip(Y,X), key=lambda pair: pair[0])]
Explained:
zip the two lists.- create a new, sorted
list based on the zip using sorted().
- using a list comprehension extract the first elements of each pair from the sorted, zipped
list.
For more information on how to set\use the key parameter as well as the sorted function in general, take a look at this.
回答 1
将两个列表压缩在一起，对其进行排序，然后选择所需的部分：
>>> 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 the two lists together, sort it, then take the parts you want:
>>> 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']
Combine these together to get:
[x for y, x in sorted(zip(Y, X))]
回答 2
另外，如果您不介意使用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/
Also, if you don’t mind using numpy arrays (or in fact already are dealing with numpy arrays…), here is another nice solution:
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]
I found it here:
http://scienceoss.com/sort-one-list-by-another-list/
回答 3
对我来说，最明显的解决方案是使用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)
The most obvious solution to me is to use the key keyword 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']
Note that you can shorten this to a one-liner if you care to:
>>> X.sort(key=dict(zip(X, Y)).get)
回答 4
我实际上是来这里寻找按值匹配的列表对列表进行排序的。
list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']
I actually came here looking to sort a list by a list where the values matched.
list_a = ['foo', 'bar', 'baz']
list_b = ['baz', 'bar', 'foo']
sorted(list_b, key=lambda x: list_a.index(x))
# ['foo', 'bar', 'baz']
回答 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')
more_itertools has a tool for sorting iterables in parallel:
Given
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]
Demo
sort_together([Y, X])[1]
# ('a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g')
回答 6
我喜欢列出排序索引。这样，我可以按照与源列表相同的顺序对任何列表进行排序。一旦有了排序索引的列表，简单的列表理解就可以解决问题：
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()。
I like having a list of sorted indices. That way, I can sort any list in the same order as the source list. Once you have a list of sorted indices, a simple list comprehension will do the trick:
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"]
Note that the sorted index list can also be gotten using numpy.argsort().
回答 7
另一个选择，结合几个答案。
zip(*sorted(zip(Y,X)))[1]
为了使用python3：
list(zip(*sorted(zip(B,A))))[1]
Another alternative, combining several of the answers.
zip(*sorted(zip(Y,X)))[1]
In order to work for python3:
list(zip(*sorted(zip(B,A))))[1]
回答 8
zip，按第二列排序，返回第一列。
zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]
zip, sort by the second column, return the first column.
zip(*sorted(zip(X,Y), key=operator.itemgetter(1)))[0]
回答 9
快速的单线。
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))
当需要将较小的列表排序为较大的值时，这将很有帮助。假设较大的列表包含较小列表中的所有值，则可以完成此操作。
A quick one-liner.
list_a = [5,4,3,2,1]
list_b = [1,1.5,1.75,2,3,3.5,3.75,4,5]
Say you want list a to match list b.
orderedList = sorted(list_a, key=lambda x: list_b.index(x))
This is helpful when needing to order a smaller list to values in larger. Assuming that the larger list contains all values in the smaller list, it can be done.
回答 10
您可以创建一个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']
You can create a pandas Series, using the primary list as data and the other list as index, and then just sort by the index:
import pandas as pd
pd.Series(data=X,index=Y).sort_index().tolist()
output:
['a', 'd', 'h', 'b', 'c', 'e', 'i', 'f', 'g']
回答 11
如果您想同时获得两个排序列表（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是元组即可。如果有更好的方法，我也在徘徊。
警告：如果使用空列表运行它，则会崩溃。
Here is Whatangs answer if you want to get both sorted lists (python3).
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']
Just remember Zx and Zy are tuples.
I am also wandering if there is a better way to do that.
Warning: If you run it with empty lists it crashes.
回答 12
我创建了一个更通用的函数，该函数根据@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
I have created a more general function, that sorts more than two lists based on another one, inspired by @Whatang’s answer.
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
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)
list1 = ['a','b','c','d','e','f','g','h','i']
list2 = [0,1,1,0,1,2,2,0,1]
output=[]
cur_loclist = []
To get unique values present in list2
list_set = set(list2)
To find the loc of the index in list2
list_str = ''.join(str(s) for s in list2)
Location of index in list2 is tracked using 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)
回答 14
这是一个古老的问题，但是我看到的一些答案由于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），依此类推。这会造成不稳定除非您为字典顺序包括原始列表索引，以使重复项保持原始顺序，否则输出。
这使您可以更直接地控制对输入进行排序的方式，因此您可以通过简单地说明要作为排序依据的特定键来获得排序稳定性。在这里查看更多示例。
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')
This is an old question but some of the answers I see posted don’t actually work because zip is not scriptable. Other answers didn’t bother to import operator and provide more info about this module and its benefits here.
There are at least two good idioms for this problem. Starting with the example input you provided:
X = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
Y = [ 0, 1, 1, 0, 1, 2, 2, 0, 1 ]
This is also known as the Schwartzian_transform after R. Schwartz who popularized this pattern in Perl in the 90s:
# 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')
Note that in this case Y and X are sorted and compared lexicographically. That is, the first items (from Y) are compared; and if they are the same then the second items (from X) are compared, and so on. This can create unstable outputs unless you include the original list indices for the lexicographic ordering to keep duplicates in their original order.
This gives you more direct control over how to sort the input, so you can get sorting stability by simply stating the specific key to sort by. See more examples 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')
