StopIteration会让python变慢吗？

Question

据我所知,监视异常会使程序变慢.

是否StopIteration会有迭代器异常监视器,例如使for循环变慢？

Answer 1

虽然异常监视在通常情况下有一些小开销,但在迭代器的情况下,处理StopIteration异常似乎没有任何开销.Python将迭代器优化为一种特殊情况,因此StopIteration不涉及任何异常处理程序.(我也会观察---我可能会遗漏一些东西 - 很难想出一个for不会隐式使用迭代器的Python 循环).

这里有一些例子,首先使用内置range函数和一个简单的for循环:

Python 2.7.5
>>> import dis
>>> def x():
...   for i in range(1,11):
...     pass
...
>>> dis.dis(x)
  2           0 SETUP_LOOP              23 (to 26)
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (1)
              9 LOAD_CONST               2 (11)
             12 CALL_FUNCTION            2
             15 GET_ITER
        >>   16 FOR_ITER                 6 (to 25)
             19 STORE_FAST               0 (i)

  3          22 JUMP_ABSOLUTE           16
        >>   25 POP_BLOCK
        >>   26 LOAD_CONST               0 (None)
             29 RETURN_VALUE

请注意,范围基本上被视为迭代器.

现在,使用一个简单的生成器函数:

>>> def g(x):
...   while x < 11:
...     yield x
...     x = x + 1
...
>>> def y():
...   for i in g(1):
...     pass
...
>>> dis.dis(y)
  2           0 SETUP_LOOP              20 (to 23)
              3 LOAD_GLOBAL              0 (g)
              6 LOAD_CONST               1 (1)
              9 CALL_FUNCTION            1
             12 GET_ITER
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_FAST               0 (i)

  3          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK
        >>   23 LOAD_CONST               0 (None)
             26 RETURN_VALUE
>>> dis.dis(g)
  2           0 SETUP_LOOP              31 (to 34)
        >>    3 LOAD_FAST                0 (x)
              6 LOAD_CONST               1 (11)
              9 COMPARE_OP               0 (<)
             12 POP_JUMP_IF_FALSE       33

  3          15 LOAD_FAST                0 (x)
             18 YIELD_VALUE
             19 POP_TOP

  4          20 LOAD_FAST                0 (x)
             23 LOAD_CONST               2 (1)
             26 BINARY_ADD
             27 STORE_FAST               0 (x)
             30 JUMP_ABSOLUTE            3
        >>   33 POP_BLOCK
        >>   34 LOAD_CONST               0 (None)
             37 RETURN_VALUE

注意,y这里基本上与x上面相同,区别是一条LOAD_CONST指令,因为x引用数字11.同样,我们的简单生成器基本上等同于写入while循环的相同内容:

>>> def q():
...   x = 1
...   while x < 11:
...     x = x + 1
...
>>> dis.dis(q)
  2           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (x)

  3           6 SETUP_LOOP              26 (to 35)
        >>    9 LOAD_FAST                0 (x)
             12 LOAD_CONST               2 (11)
             15 COMPARE_OP               0 (<)
             18 POP_JUMP_IF_FALSE       34

  4          21 LOAD_FAST                0 (x)
             24 LOAD_CONST               1 (1)
             27 BINARY_ADD
             28 STORE_FAST               0 (x)
             31 JUMP_ABSOLUTE            9
        >>   34 POP_BLOCK
        >>   35 LOAD_CONST               0 (None)
             38 RETURN_VALUE

同样,处理迭代器或生成器没有特定的开销(range可能比生成器版本更优化,只是因为它是内置的,但不是由于Python处理它的方式).

最后,让我们看一下用它编写的实际显式迭代器 StopIteration

>>> class G(object):
...   def __init__(self, x):
...     self.x = x
...   def __iter__(self):
...     return self
...   def next(self):
...     x = self.x
...     if x >= 11:
...       raise StopIteration
...     x = x + 1
...     return x - 1
...
>>> dis.dis(G.next)
  7           0 LOAD_FAST                0 (self)
              3 LOAD_ATTR                0 (x)
              6 STORE_FAST               1 (x)

  8           9 LOAD_FAST                1 (x)
             12 LOAD_CONST               1 (11)
             15 COMPARE_OP               5 (>=)
             18 POP_JUMP_IF_FALSE       30

  9          21 LOAD_GLOBAL              1 (StopIteration)
             24 RAISE_VARARGS            1
             27 JUMP_FORWARD             0 (to 30)

 10     >>   30 LOAD_FAST                1 (x)
             33 LOAD_CONST               2 (1)
             36 BINARY_ADD
             37 STORE_FAST               1 (x)

 11          40 LOAD_FAST                1 (x)
             43 LOAD_CONST               2 (1)
             46 BINARY_SUBTRACT
             47 RETURN_VALUE

现在,我们可以看到生成器函数比这个简单的迭代器涉及的指令要少一些,主要与实现的差异以及与引发StopIteration异常相关的一些指令有关.然而,使用这个迭代器的函数完全等同于y上面:

>>> def z():
...   for i in G(1):
...     pass
...
>>> dis.dis(z)
  2           0 SETUP_LOOP              20 (to 23)
              3 LOAD_GLOBAL              0 (G)
              6 LOAD_CONST               1 (1)
              9 CALL_FUNCTION            1
             12 GET_ITER
        >>   13 FOR_ITER                 6 (to 22)
             16 STORE_FAST               0 (i)

  3          19 JUMP_ABSOLUTE           13
        >>   22 POP_BLOCK
        >>   23 LOAD_CONST               0 (None)
             26 RETURN_VALUE

当然,这些结果是基于Python for循环将优化迭代器以消除StopIteration异常的显式处理程序的需要.毕竟,StopIteration异常基本上构成了Python for循环操作的正常部分.

关于为什么以这种方式实现,请参阅定义迭代器的PEP-234.这专门解决了例外费用的问题:

• 有人质疑,发出迭代结束信号的异常是否过于昂贵.已经提出了几种StopIteration异常的替代方法:一个特殊值End表示结束信号,一个函数end()来测试迭代器是否完成,甚至重用IndexError异常.

  • 特殊值的问题是,如果序列包含该特殊值,则该序列上的循环将过早结束而不会发出任何警告.如果使用以null结尾的C字符串的经验并没有告诉我们这可能导致的问题,那么想象一下Python内省工具将迭代所有内置名称列表的麻烦,假设特殊的End值是一个内置的在名字!

  • 调用end()函数每次迭代需要两次调用.两个调用比一个调用和一个异常测试要昂贵得多.特别是循环的时间关键可以非常便宜地测试异常.

  • 重用IndexError可能会导致混淆,因为它可能是一个真正的错误,它会被过早结束循环所掩盖.