`operator.itemgetter`的倒数

Question

我最近在this question上工作。本质上，my answer涉及到对sorted的调用，并使用lambda作为key：

sorted(range(len(L)), key=lambda i : L[i])

考虑到性能是问题的核心，而且lambda本身就很慢，我可以通过定义一个函数并使用它来代替lambda来进行一些优化。

尽管如此，我仍然觉得我会重新发明轮子。必须有一个内置的函数在某个地方或在某个支持import的模块中提供__getitem__的功能(我不想使用的唯一原因是，使用损坏的方法并不是真正的pythonic )。

我知道operator.getitem，它让我预定义一个索引i，并在任何输入序列中获取i处的元素。但是有没有一个函数(比如foo)的工作原理如下：

In [14]: g = operator.itemgetter(1)

In [15]: d = {'a':1, 'b':2, 'c':3, 'd':4}

In [16]: for i in d.iteritems():
   ....:     print g(i),
   ....:     
1 3 2 4

In [17]: L = list('abcd')

In [18]: g = foo(L)

In [19]: for i in range(4):
   ....:     print g(i),
   ....:     
'a' 'b' 'c' 'd'

很抱歉，如果这是一个重复的问题，但我能想到的搜索词没有给出结果。

Answer 1

如果我没弄错你想要什么，下面的代码就能做到：

import functools
import operator

L = list('abcd')

def foo(indexable):
    return functools.partial(operator.__getitem__, indexable)

g = foo(L)

for i in xrange(len(L)):
    print g(i),

更新：

我做了进一步的实验，惊讶地发现了一个稍微快一点的解决方案，就是这个简单的解决方案：

def foo2(indexable):
    return indexable.__getitem__

当使用我拼凑在一起的一个小测试床运行时，它产生了以下结果：

fastest to slowest *_test() function timings:
 10,000 elements, 1,000 timeit calls, best of 3

  foo2_test() : 1.46 (0.00 times slower)
lambda_test() : 4.15 (1.84 times slower)
   foo_test() : 4.28 (1.93 times slower)

每个测试函数使用不同的技术在一个紧密的循环中访问列表中的每个元素。

我很好奇这是如何应用于对链接问题的排序答案的，我使用它对列表进行排序，而不是只访问列表的每个元素一次，从而获得了这些不同的结果：

fastest to slowest *_test() function timings:
 10,000 elements, 1,000 timeit calls, best of 3

  foo2_test() : 13.03 (0.00 times slower)
   foo_test() : 14.70 (0.13 times slower)
lambda_test() : 16.25 (0.25 times slower)

虽然foo2()在这两种情况下都是最快的，但在排序版本中，它只是非常小的一部分。

下面是用于获取简单访问的第一组结果的完整测试床的清单：

import functools
import operator

import timeit
import types

N = 1000
R = 3
SZ = 10000
SUFFIX = '_test'
SUFFIX_LEN = len(SUFFIX)

def setup():
    import random
    global a_list
    a_list = [random.randrange(100) for _ in xrange(SZ)]

def lambda_test():
    global a_list
    f = lambda i: a_list[i]
    for i in xrange(len(a_list)): f(i)

def foo(indexable):
    return functools.partial(operator.__getitem__, indexable)

def foo_test():
    global a_list
    g = foo(a_list)
    for i in xrange(len(a_list)): g(i)

def foo2(indexable):
    return indexable.__getitem__

def foo2_test():
    global a_list
    g = foo2(a_list)
    for i in xrange(len(a_list)): g(i)

# find all the functions named *SUFFIX in the global namespace
funcs = tuple(value for id,value in globals().items()
            if id.endswith(SUFFIX) and type(value) is types.FunctionType)

# run the timing tests and collect results
timings = [(f.func_name[:-SUFFIX_LEN],
            min(timeit.repeat(f, setup=setup, repeat=R, number=N))
           ) for f in funcs]
timings.sort(key=lambda x: x[1])  # sort by speed (ironic use of lambda?)
fastest = timings[0][1]  # time fastest one took to run
longest = max(len(t[0]) for t in timings) # len of longest func name (w/o suffix)

print 'fastest to slowest *_test() function timings:\n' \
      ' {:,d} elements, {:,d} timeit calls, best of {:d}\n'.format(SZ, N, R)

def times_slower(speed, fastest):
    return speed/fastest - 1.0

for i in timings:
    print "{0:>{width}}{suffix}() : {1:.2f} ({2:.2f} times slower)".format(
                i[0], i[1], times_slower(i[1], fastest), width=longest, suffix=SUFFIX)

下面是测试排序用法时的不同之处：

def setup():
    import random
    global a_list
    a_list = [random.randrange(100) for _ in xrange(SZ)]

def lambda_test():
    global a_list
    sorted(range(len(a_list)), key=lambda i:a_list[i])

def foo(indexable):
    return functools.partial(operator.__getitem__, indexable)

def foo_test():
    global a_list
    sorted(range(len(a_list)), key=foo(a_list))

def foo2(indexable):
    return indexable.__getitem__

def foo2_test():
    global a_list
    sorted(range(len(a_list)), key=foo2(a_list))