使用另一个列表对元组列表进行排序

Question

我有一个元组列表to_order 如：

to_order = [(0, 1), (1, 3), (2, 2), (3,2)]

还有一个列表，它给出了应用于to_order 的每个元组的第二个元素的顺序：

order = [2, 1, 3]

所以我正在寻找一种方法来获得这个输出：

ordered_list = [(2, 2), (3,2), (0, 1), (1, 3)]

有什么想法吗？

Answer 1

您可以提供一个key，它将检查order 中的（第二个元素的）索引并根据它进行排序：

to_order = [(0, 1), (1, 3), (2, 2), (3,2)]
order = [2, 1, 3]
print(sorted(to_order, key=lambda item: order.index(item[1]))) # [(2, 2), (3, 2), (0, 1), (1, 3)]

编辑

既然开始了关于时间复杂性的讨论……来吧，下面的算法在O(n+m) 中运行，使用 Eric 的输入示例：

N = 5
to_order = [(randrange(N), randrange(N)) for _ in range(10*N)]
order = list(set(pair[1] for pair in to_order))
shuffle(order)


def eric_sort(to_order, order):
    bins = {}

    for pair in to_order:
        bins.setdefault(pair[1], []).append(pair)

    return [pair for i in order for pair in bins[i]]


def alfasin_new_sort(to_order, order):
    arr = [[] for i in range(len(order))]
    d = {k:v for v, k in enumerate(order)}
    for item in to_order:
        arr[d[item[1]]].append(item) 
    return [item for sublist in arr for item in sublist]


from timeit import timeit
print("eric_sort", timeit("eric_sort(to_order, order)", setup=setup, number=1000))
print("alfasin_new_sort", timeit("alfasin_new_sort(to_order, order)", setup=setup, number=1000))

输出：

eric_sort 59.282021682999584
alfasin_new_sort 44.28244407700004

Answer 2

算法

您可以根据第二个元素将元组分布在列表的字典中，并遍历order 索引以获得排序列表：

from collections import defaultdict
to_order = [(0, 1), (1, 3), (2, 2), (3, 2)]
order = [2, 1, 3]

bins = defaultdict(list)

for pair in to_order:
    bins[pair[1]].append(pair)

print(bins)
# defaultdict(<class 'list'>, {1: [(0, 1)], 3: [(1, 3)], 2: [(2, 2), (3, 2)]})

print([pair for i in order for pair in bins[i]])
# [(2, 2), (3, 2), (0, 1), (1, 3)]

不需要sort或index，输出稳定。

该算法类似于假定的duplicate 中提到的mapping。此链接答案仅在 to_order 和 order 具有相同长度时才有效，而 OP 的问题并非如此。

性能

此算法对to_order 的每个元素进行两次迭代。复杂度为O(n)。 @alfasin 的第一个算法要慢得多（O(n * m * log n)），但他的第二个算法也是O(n)。

这是一个列表，在 0 和 1000 之间有 10000 个随机对。我们提取唯一的第二个元素并打乱它们以定义order：

from random import randrange, shuffle
from collections import defaultdict
from timeit import timeit
from itertools import chain

N = 1000
to_order = [(randrange(N), randrange(N)) for _ in range(10*N)]
order = list(set(pair[1] for pair in to_order))
shuffle(order)


def eric(to_order, order):
    bins = defaultdict(list)
    for pair in to_order:
        bins[pair[1]].append(pair)
    return list(chain.from_iterable(bins[i] for i in order))


def alfasin1(to_order, order):
    arr = [[] for i in range(len(order))]
    d = {k:v for v, k in enumerate(order)}
    for item in to_order:
        arr[d[item[1]]].append(item) 
    return [item for sublist in arr for item in sublist]

def alfasin2(to_order, order):
    return sorted(to_order, key=lambda item: order.index(item[1]))

print(eric(to_order, order) == alfasin1(to_order, order))
# True
print(eric(to_order, order) == alfasin2(to_order, order))
# True

print("eric", timeit("eric(to_order, order)", globals=globals(), number=100))
# eric 0.3117517130003762
print("alfasin1", timeit("alfasin1(to_order, order)", globals=globals(), number=100))
# alfasin1 0.36100843100030033
print("alfasin2", timeit("alfasin2(to_order, order)", globals=globals(), number=100))
# alfasin2 15.031453827000405

Answer 3

另一种解决方案： [item for key in order for item in filter(lambda x: x[1] == key, to_order)]

此解决方案首先使用order，为order 中的每个key 过滤to_order。

等效：

ordered = []
for key in order:
    for item in filter(lambda x: x[1] == key, to_order):
        ordered.append(item)

更短，但我不知道如何通过列表理解来做到这一点：

ordered = []
for key in order:
    ordered.extend(filter(lambda x: x[1] == key, to_order))

注意：如果to_order 包含元组x，其中x[1] 不在order 中，则不会抛出ValueError。

Answer 4

我个人更喜欢list 对象sort 函数而不是内置的sort，它生成一个新列表而不是更改列表。

to_order = [(0, 1), (1, 3), (2, 2), (3,2)]
order = [2, 1, 3]
to_order.sort(key=lambda x: order.index(x[1]))
print(to_order)
>[(2, 2), (3, 2), (0, 1), (1, 3)]

顺便解释一下：sort方法的key参数基本上preprocesses列表和ranks都是基于一个度量的值。在我们的例子中，order.index() 查看当前处理项目的第一次出现并返回其位置。

x = [1,2,3,4,5,3,3,5]
print x.index(5)
>4