有效访问索引：在字典中存储索引是最快的方式吗？

Question

我有一个需要重复访问索引的元组列表。 这样做的最快方法是将元组及其索引存储在字典中吗？ 或者，还有更好的方法？

给定一个存在于元组有序列表中的元组，我需要有效地访问它的索引。 我可以想到两种方法来做到这一点； 在列表上调用.index ，或者将元组作为键存储在字典中，索引作为它们的值，并通过字典查找来查找索引。

order = list(itertools.product(range(4),repeat=6))
%timeit order.index(random.choice(order))
# 10000 loops, best of 3: 35 µs per loop

order_dic = {i:order.index(i) for i in order}
%timeit order_dic[random.choice(order)]
# 1000000 loops, best of 3: 443 ns per loop

Answer 1

几乎总是，第二个选项会更快。 这是因为在第一个示例中，您搜索列表以找到索引，这是对列表的O(n)操作。 而在第二个示例中，您在字典中查找一个值，平均为O(1) 。

但是，这里需要考虑空间，因为第二个选项具有额外 dict 的开销。 在 Brandon Rhodes 在 Pycon 2014 的演讲中，他说 dicts 使用的空间往往是它们需要的空间的3 到 4 倍，因此添加新元素仍然很快，如果您有大量元组列表，这可能会带来很多开销。

如果您用作示例的元组列表实际上是您正在搜索的列表，那么有一种快速且节省内存的方法来计算给定元组的索引，这依赖于itertools.product工作方式：

a[5] + a[4] >> 2 + a[3] >> 4 + a[2] >> 6 + a[1] >> 8 + a[0] >> 10

这将给出元组a的索引。 这几乎与第二个选项一样快，但没有额外 dict 的额外空间要求。

（这种方法背后的想法是元组本质上是一个六位数的以四为基数的数字，并且由于itertools.product按顺序输出它们，这将给出索引。）

Answer 2

看起来真的很难比dict()更快。 看看random.choice()在没有任何查找的情况下需要多长时间：

>>> order = list(itertools.product(range(4),repeat=6))
>>> order_dic = {i:order.index(i) for i in order}

>>> %timeit order.index(random.choice(order))
>>> %timeit order_dic[random.choice(order)]
>>> %timeit random.choice(order)

10000 loops, best of 3: 98.6 µs per loop
1000000 loops, best of 3: 1.6 µs per loop
1000000 loops, best of 3: 1.39 µs per loop

因此，查找仅占您测量的总数的 15%。

但也许您可以考虑将索引存储在元组中？ 或者将元组存储在另一个也有索引的元组中？ 例如order = list(enumerate(order)) 。

您可以为每个元组对象分配索引：

order = list(itertools.product(range(4),repeat=6))
order_dic = {i:order.index(i) for i in order}

%timeit order.index(random.choice(order))
%timeit order_dic[random.choice(order)]
%timeit random.choice(order)

class mytuple(tuple): pass

order = list(map(mytuple, order))
for i, t in enumerate(order): t.rev_index = i

%timeit random.choice(order).rev_index

## -- End pasted text --
10000 loops, best of 3: 101 µs per loop
1000000 loops, best of 3: 1.59 µs per loop
1000000 loops, best of 3: 1.44 µs per loop
1000000 loops, best of 3: 1.53 µs per loop

它比哈希映射更快。

您无法动态设置内置函数的属性，因此我们必须对其进行子类化。 我们也不能使用__slots__因为像tuple这样的可变大小类型不支持它，所以每个mytuple都会有一个额外的__dict__ 。 但显然，与使用一个dict来映射所有索引相比，这仍然具有更小的内存占用（几乎两倍）：

>>> from pympler.asizeof import asizeof
>>> asizeof(order_dic) \
... / (asizeof(order) - asizeof(list(itertools.product(range(4),repeat=6))))
1.8341168569509738