您正在使用太小的输入进行测试；虽然与列表理解相比，字典理解对于循环的没有那么大的性能优势，但对于现实的问题大小，它可以而且确实优于循环的，尤其是针对全球名称时。

您的输入仅由3个键值对组成。相反，使用1000个元素进行测试，我们发现计时非常接近：

>>> import timeit
>>> from random import choice, randint; from string import ascii_lowercase as letters
>>> looped = '''\
... b = {}
... for i,j in a.items():
...     b[j]=i
... '''
>>> dictcomp = '''b = {v: k for k, v in a.items()}'''
>>> def rs(): return ''.join([choice(letters) for _ in range(randint(3, 15))])
...
>>> a = {rs(): rs() for _ in range(1000)}
>>> len(a)
1000
>>> count, total = timeit.Timer(looped, 'from __main__ import a').autorange()
>>> (total / count) * 1000000   # microseconds per run
66.62004760000855
>>> count, total = timeit.Timer(dictcomp, 'from __main__ import a').autorange()
>>> (total / count) * 1000000   # microseconds per run
64.5464928005822

不同之处在于，dict comp速度更快，但仅限于此规模。由于键值对的数量是原来的100倍，因此差异要大一些：

>>> a = {rs(): rs() for _ in range(100000)}
>>> len(a)
98476
>>> count, total = timeit.Timer(looped, 'from __main__ import a').autorange()
>>> total / count * 1000  # milliseconds, different scale!
15.48140200029593
>>> count, total = timeit.Timer(dictcomp, 'from __main__ import a').autorange()
>>> total / count * 1000  # milliseconds, different scale!
13.674790799996117

当考虑两个处理的近100K键值对时，这并不是很大的差别。不过，for的循环显然要慢一些。

那么，为什么3个元素的速度差异？因为理解（字典、集合、列表理解或生成器表达式）是作为新函数实现的，调用该函数有一个基本成本，普通循环不必支付。

下面是两个备选方案的字节码反汇编；请注意，对于dict理解，顶级字节码中的MAKE_函数和CALL_函数操作码有一个单独的部分说明该函数的作用，实际上这两种方法之间几乎没有区别：

>>> import dis
>>> dis.dis(looped)
  1           0 BUILD_MAP                0
              2 STORE_NAME               0 (b)

  2           4 SETUP_LOOP              28 (to 34)
              6 LOAD_NAME                1 (a)
              8 LOAD_METHOD              2 (items)
             10 CALL_METHOD              0
             12 GET_ITER
        >>   14 FOR_ITER                16 (to 32)
             16 UNPACK_SEQUENCE          2
             18 STORE_NAME               3 (i)
             20 STORE_NAME               4 (j)

  3          22 LOAD_NAME                3 (i)
             24 LOAD_NAME                0 (b)
             26 LOAD_NAME                4 (j)
             28 STORE_SUBSCR
             30 JUMP_ABSOLUTE           14
        >>   32 POP_BLOCK
        >>   34 LOAD_CONST               0 (None)
             36 RETURN_VALUE
>>> dis.dis(dictcomp)
  1           0 LOAD_CONST               0 (<code object <dictcomp> at 0x11d6ade40, file "<dis>", line 1>)
              2 LOAD_CONST               1 ('<dictcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_NAME                0 (a)
              8 LOAD_METHOD              1 (items)
             10 CALL_METHOD              0
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 STORE_NAME               2 (b)
             18 LOAD_CONST               2 (None)
             20 RETURN_VALUE

Disassembly of <code object <dictcomp> at 0x11d6ade40, file "<dis>", line 1>:
  1           0 BUILD_MAP                0
              2 LOAD_FAST                0 (.0)
        >>    4 FOR_ITER                14 (to 20)
              6 UNPACK_SEQUENCE          2
              8 STORE_FAST               1 (k)
             10 STORE_FAST               2 (v)
             12 LOAD_FAST                1 (k)
             14 LOAD_FAST                2 (v)
             16 MAP_ADD                  2
             18 JUMP_ABSOLUTE            4
        >>   20 RETURN_VALUE

实质上的区别：循环代码在每次迭代中使用LOAD_NAME进行b，而STORE_SUBSCR将键值对存储在dico加载中。字典理解使用MAP_ADD来实现与STORE_SUBSCR相同的东西，但不必每次都加载那个b名称。

但是只有3次迭代，dict理解必须执行的MAKE_函数/CALL_函数组合才是性能的真正阻力：

>>> make_and_call = '(lambda i: None)(None)'
>>> dis.dis(make_and_call)
  1           0 LOAD_CONST               0 (<code object <lambda> at 0x11d6ab270, file "<dis>", line 1>)
              2 LOAD_CONST               1 ('<lambda>')
              4 MAKE_FUNCTION            0
              6 LOAD_CONST               2 (None)
              8 CALL_FUNCTION            1
             10 RETURN_VALUE

Disassembly of <code object <lambda> at 0x11d6ab270, file "<dis>", line 1>:
  1           0 LOAD_CONST               0 (None)
              2 RETURN_VALUE
>>> count, total = timeit.Timer(make_and_call).autorange()
>>> total / count * 1000000
0.12945385499915574

超过0.1μs来创建一个带有一个参数的函数对象，并调用它（对于传入的None值，使用额外的LOAD_CONST）！这就是3个键值对的循环计时和理解计时之间的差异。

你可以把这比作一个人用铲子挖一个小洞比反铲挖得快而感到惊讶。反铲当然可以挖得很快，但是如果你需要先启动反铲并将其移动到位，那么一个带铲的人可以更快地开始工作！

除了几个键值对（挖一个更大的洞），函数create和call cost逐渐消失为虚无。此时，dict理解和显式循环基本上做了相同的事情：

• 获取下一个键值对，弹出堆栈上的键值对
• 通过一个字节码操作调用，__setitem__钩子，其中有堆栈上的前两个项目（要么是STORE_SUBSCR，要么是MAP_ADD。这不能算作函数调用，因为它都是在解释器循环中内部处理的。

这与列表理解不同，普通循环版本必须使用list。append（），涉及属性查找和每个循环迭代的函数调用。列表理解速度的优势来自于这种差异；请参见Python列表

当将b绑定到最终字典对象时，目标字典名称只需要查找一次。如果目标字典是一个全局变量而不是一个局部变量，那么理解力就赢了：

>>> a = {rs(): rs() for _ in range(1000)}
>>> len(a)
1000
>>> namespace = {}
>>> count, total = timeit.Timer(looped, 'from __main__ import a; global b', globals=namespace).autorange()
>>> (total / count) * 1000000
76.72348440100905
>>> count, total = timeit.Timer(dictcomp, 'from __main__ import a; global b', globals=namespace).autorange()
>>> (total / count) * 1000000
64.72114819916897
>>> len(namespace['b'])
1000

所以只要用一个判断理解。与的区别