关于性能：什么是Python中最快的(访问)类似结构的对象？

What is the fastest (to access) struct-like object in Python?

我正在优化一些代码，它们的主要瓶颈正在运行，并访问大量类似结构的对象。为了可读性，目前我使用的是namedtuples。但一些使用"TimeIt"的快速基准测试表明，如果性能是一个因素，那么这确实是一种错误的方式：

名为a、b、c的元组：

1 2	>>> timeit("z = a.c","from __main__ import a") 0.38655471766332994

使用__slots__的类，带有a、b、c：

1 2	>>> timeit("z = b.c","from __main__ import b") 0.14527461047146062

带A、B、C键的字典：

1 2	>>> timeit("z = c['c']","from __main__ import c") 0.11588272541098377

使用常量键创建三个值的元组：

1 2	>>> timeit("z = d[2]","from __main__ import d") 0.11106188992948773

使用常量键列出三个值：

1 2	>>> timeit("z = e[2]","from __main__ import e") 0.086038238242508669

三个值的元组，使用本地键：

1 2	>>> timeit("z = d[key]","from __main__ import d, key") 0.11187358437882722

使用本地键列出三个值：

1 2	>>> timeit("z = e[key]","from __main__ import e, key") 0.088604143037173344

首先，这些小的timeit测试是否会使它们失效？我每运行几次，以确保没有任何随机系统事件丢弃它们，结果几乎相同。

字典似乎在性能和可读性之间提供了最佳的平衡，类排在第二位。这是不幸的，因为出于我的目的，我也需要对象的顺序，因此我选择了命名的两个。

列表速度快得多，但常量键是不可维护的；我必须创建一组索引常量，即key_1=1、key_2=2等，这也是不理想的。

我是坚持这些选择，还是有我错过的选择？

相关讨论

这个问题相当古老(互联网时间)，所以我想今天我会尝试复制你的测试，包括常规的cpython(2.7.6)和pypy(2.2.1)，看看各种方法之间的比较。(我还为命名的元组添加了索引查找。)

这是一个微基准测试，所以ymmv，但pypy似乎比cpython加快了30倍的命名tuple访问速度(而字典访问速度只加快了3倍)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

from collections import namedtuple

STest = namedtuple("TEST","a b c")
a = STest(a=1,b=2,c=3)

class Test(object):
__slots__ = ["a","b","c"]

a=1
b=2
c=3

b = Test()

c = {'a':1, 'b':2, 'c':3}

d = (1,2,3)
e = [1,2,3]
f = (1,2,3)
g = [1,2,3]
key = 2

if __name__ == '__main__':
from timeit import timeit

print("Named tuple with a, b, c:")
print(timeit("z = a.c","from __main__ import a"))

print("Named tuple, using index:")
print(timeit("z = a[2]","from __main__ import a"))

print("Class using __slots__, with a, b, c:")
print(timeit("z = b.c","from __main__ import b"))

print("Dictionary with keys a, b, c:")
print(timeit("z = c['c']","from __main__ import c"))

print("Tuple with three values, using a constant key:")
print(timeit("z = d[2]","from __main__ import d"))

print("List with three values, using a constant key:")
print(timeit("z = e[2]","from __main__ import e"))

print("Tuple with three values, using a local key:")
print(timeit("z = d[key]","from __main__ import d, key"))

print("List with three values, using a local key:")
print(timeit("z = e[key]","from __main__ import e, key"))

Python结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Named tuple with a, b, c:
0.124072679784
Named tuple, using index:
0.0447055962367
Class using __slots__, with a, b, c:
0.0409136944224
Dictionary with keys a, b, c:
0.0412045334915
Tuple with three values, using a constant key:
0.0449477955531
List with three values, using a constant key:
0.0331083467148
Tuple with three values, using a local key:
0.0453569025139
List with three values, using a local key:
0.033030056702

PyPy结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Named tuple with a, b, c:
0.00444889068604
Named tuple, using index:
0.00265598297119
Class using __slots__, with a, b, c:
0.00208616256714
Dictionary with keys a, b, c:
0.013897895813
Tuple with three values, using a constant key:
0.00275301933289
List with three values, using a constant key:
0.002760887146
Tuple with three values, using a local key:
0.002769947052
List with three values, using a local key:
0.00278806686401