据我所知，监控异常会使程序变慢。
迭代器异常监视器（例如StopIteration）会使for循环变慢吗？
答案 0 :(得分：6)
虽然异常监视在通常情况下有一些小的开销，但在迭代器的情况下，处理StopIteration异常似乎没有任何开销。 Python将迭代器优化为一种特殊情况，因此StopIteration不涉及任何异常处理程序。 （我也会观察---我可能会遗漏一些东西 - 很难想出一个不会隐式使用迭代器的Python for循环。）
以下是一些示例，首先使用内置的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（）函数需要每次调用两次 迭代。两个电话比一个电话贵得多 加上例外测试。特别是时间紧迫 for循环可以非常便宜地测试异常。
重用IndexError会导致混淆，因为它可能是a 真正的错误，可以通过结束循环来掩盖 过早。
答案 1 :(得分：2)
查看由具有try和except块的函数生成的字节码的输出，看起来它会稍微慢一点，但是，在大多数情况下，这实际上可以忽略不计，因为它只要性能受到影响，非常小。我认为在进行这样的优化时要考虑的事实是正确地确定异常。
编译为字节码时，try / except块的示例函数输出：
Python 2.7.3 (default, Apr 10 2012, 23:31:26) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> import dis
>>> def x():
try:
sd="lol"
except:
raise
>>> dis.dis(x)
2 0 SETUP_EXCEPT 10 (to 13)
3 3 LOAD_CONST 1 ('lol')
6 STORE_FAST 0 (sd)
9 POP_BLOCK
10 JUMP_FORWARD 10 (to 23)
4 >> 13 POP_TOP
14 POP_TOP
15 POP_TOP
5 16 RAISE_VARARGS 0
19 JUMP_FORWARD 1 (to 23)
22 END_FINALLY
>> 23 LOAD_CONST 0 (None)
26 RETURN_VALUE
>>>