Python：从有序列表中对键的子列表进行排序的最快方法是什么

Question

I have a question about speed in sorting an unordered sublist of keys from a long list of keys. So

keys =['a','c','b','f','e','d','p','t','s','y','h']
sub_list = ['y','b','a','p']

I have two ideas:

sublist = sorted(sub_list, key=keys)

or,

sublist = [key for key in keys if key in sub_list]

There might be better ways than these two for all I know. Any thoughts?

Answer 1

Just timeit:

In [3]: %timeit sorted(sub_list, lambda a,b: cmp(keys.index(a), keys.index(b)))
100000 loops, best of 3: 6.22 us per loop

In [4]: %timeit sublist = [key for key in keys if key in sub_list]
1000000 loops, best of 3: 1.91 us per loop

EDIT (more methods) :

%timeit sorted(sub_list, key=keys.index)
100000 loops, best of 3: 2.8 us per loop

This example uses the macros (or whatever they are called in ipython ) but you can use timeit yourself by:

import timeit

p = """
keys =['a','c','b','f','e','d','p','t','s','y','h']
sub_list = ['y','b','a','p']"""

s = "sorted(sub_list, lambda a,b: cmp(keys.index(a), keys.index(b)))"

timeit.Timer(stmt=s, setup=p).timeit()
>>> 8.40028386496742

s = "[key for key in keys if key in sub_list]"
timeit.Timer(stmt=s, setup=p).timeit()
>>> 1.9661344551401498

So you can just try all the methods you can think of and choose the fastest

Answer 2

Why not just sub_list.sort() ? It may not be the fastest, but it's certainly easy to understand.

Answer 3

I think you should use sub_list.sort over sorted because .sort makes an inplace sort where sorted makes a copy of the sublist prior to sorting

the list comprehension you have made is very slow because the last if statement has to scan trough the entire sub_list (thus do n operations extra per key)

sublist = [key for key in keys if key in sub_list]

a much faster list comprehension would be this

sub_set = set(sublist)
sub_list = [key for key in keys if key in sub_set]

because hash and set look ups are O(1) where list lookups are O(n)

sorting is generally O(nlog(n)) and list comprehension are O(n)

however assuming that by:

sublist = sorted(sub_list, key=keys)

you mean:

sublist = sorted(sub_list, key=keys.index)

you have list lookups instead of hash looks up and your sorting thus goes from O(nlog(n)) to O((n**2)*log(n))

to get the sorting back to nlog(n) you have to convert your key list to a hash as follows:

keys = dict(zip(keys, range(len(keys))))
sublist = sorted(sub_list, key=keys)