python中的字典理解太全面了

debugcn 发表于 Dev

德米特里（Dmitrii Borisevich）

使用python2.7我发现了一个奇怪的时间执行案例：

data = dict( zip( a[0].split( ':' ), a[1].split( ':' ) ) )

data = { name: value for name, value in zip(a[0].split( ':' ), a[1].split( ':' )) }

这两个调用对我来说似乎绝对相同，但是，我发现字典理解版本的速度提高了约4％-不太快，但是非常稳定。

这是真的吗？如果是这样，为什么？还是仅仅是我的想象力？

马丁·彼得斯（Martijn Pieters）

您的输入样本太小。查找全局名称dict()比仅运行dict理解需要更多的时间（后者不需要名称查找），但是如果您对大量键值对进行测试，则dict()因为完全在C中完成了循环。

针对大量键/值对测试差异，并将测试简化为仅dict()调用或字典理解（zip()和str.split()调用对于两种情况仅执行一次，可以忽略）：

>>> from timeit import timeit
>>> import random
>>> from string import ascii_lowercase
>>> kv_pairs = [(''.join(random.sample(ascii_lowercase, random.randint(10, 20))), ''.join(random.sample(ascii_lowercase, random.randint(10, 20))))
...             for _ in xrange(10000)]
>>> len(dict(kv_pairs))  # the random keys happen to be all unique.
10000
>>> timeit('{k: v for k, v in kv_pairs}', 'from __main__ import kv_pairs', number=1000)
1.3174479007720947
>>> timeit('dict(kv_pairs)', 'from __main__ import kv_pairs', number=1000)
0.6737580299377441
>>> timeit('{k: v for k, v in kv_pairs}', 'from __main__ import kv_pairs; kv_pairs = kv_pairs[:3]')
0.511167049407959
>>> timeit('dict(kv_pairs)', 'from __main__ import kv_pairs; kv_pairs = kv_pairs[:3]')
0.6696300506591797

因此，对于1万个键/值对（前两个时序测试）而言，dict()速度快一倍，对于3对（后两个时序）而言，dict理解力胜了。

您可以看到为什么反编译字节码的原因；字典理解使用嵌套的代码对象来实现实际的字典构建：

>>> import dis
>>> dis.dis(compile('{k: v for k, v in kv_pairs}', '', 'exec'))
  1           0 LOAD_CONST               0 (<code object <dictcomp> at 0x102ef69b0, file "", line 1>)
              3 MAKE_FUNCTION            0
              6 LOAD_NAME                0 (kv_pairs)
              9 GET_ITER            
             10 CALL_FUNCTION            1
             13 POP_TOP             
             14 LOAD_CONST               1 (None)
             17 RETURN_VALUE        
>>> dis.dis(compile('{k: v for k, v in kv_pairs}', '', 'exec').co_consts[0])
  1           0 BUILD_MAP                0
              3 LOAD_FAST                0 (.0)
        >>    6 FOR_ITER                21 (to 30)
              9 UNPACK_SEQUENCE          2
             12 STORE_FAST               1 (k)
             15 STORE_FAST               2 (v)
             18 LOAD_FAST                2 (v)
             21 LOAD_FAST                1 (k)
             24 MAP_ADD                  2
             27 JUMP_ABSOLUTE            6
        >>   30 RETURN_VALUE        
>>> dis.dis(compile('dict(kv_pairs)', '', 'exec'))
  1           0 LOAD_NAME                0 (dict)
              3 LOAD_NAME                1 (kv_pairs)
              6 CALL_FUNCTION            1
              9 POP_TOP             
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

通过使用一个非常小的样本，您为LOAD_NAME步骤付出了dict太多的重量。dict理解涉及更多的字节码，每次迭代执行一次。

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。