这个关于perl中无限循环的问题很感兴趣:while(1)vs.for(;;)有速度差吗？,我决定在python中运行类似的比较.我期望编译器会为while(True): pass和生成相同的字节代码while(1): pass,但实际上并非python2.7中的情况.
以下脚本:
import dis
def while_one():
while 1:
pass
def while_true():
while True:
pass
print("while 1")
print("----------------------------")
dis.dis(while_one)
print("while True")
print("----------------------------")
dis.dis(while_true)
产生以下结果:
while 1
----------------------------
4 0 SETUP_LOOP 3 (to 6)
5 >> 3 JUMP_ABSOLUTE 3
>> 6 LOAD_CONST 0 (None)
9 RETURN_VALUE
while True
----------------------------
8 0 SETUP_LOOP 12 (to 15)
>> 3 LOAD_GLOBAL 0 (True)
6 JUMP_IF_FALSE 4 (to 13)
9 POP_TOP
9 10 JUMP_ABSOLUTE 3
>> 13 POP_TOP
14 POP_BLOCK
>> 15 LOAD_CONST 0 (None)
18 RETURN_VALUE
使用while True明显更复杂.为什么是这样？
在其他情况下,python的行为就好像True等于1:
>>> True == 1
True
>>> True + True
2
为什么while区分两者？
我注意到python3使用相同的操作来评估语句:
while 1
----------------------------
4 0 SETUP_LOOP 3 (to 6)
5 >> 3 JUMP_ABSOLUTE 3
>> 6 LOAD_CONST 0 (None)
9 RETURN_VALUE
while True
----------------------------
8 0 SETUP_LOOP 3 (to 6)
9 >> 3 JUMP_ABSOLUTE 3
>> 6 LOAD_CONST 0 (None)
9 RETURN_VALUE
python3是否会改变布尔值的评估方式？
ken*_*ytm 121
在Python 2.x中,True不是关键字,而只是在类型中定义为1 的内置全局常量bool.因此解释器仍然需要加载内容True.换句话说,True是可重新分配的:
Python 2.7 (r27:82508, Jul 3 2010, 21:12:11)
[GCC 4.0.1 (Apple Inc. build 5493)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> True = 4
>>> True
4
在Python 3.x中,它真正成为一个关键字和一个真正的常量:
Python 3.1.2 (r312:79147, Jul 19 2010, 21:03:37)
[GCC 4.2.1 (Apple Inc. build 5664)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> True = 4
File "<stdin>", line 1
SyntaxError: assignment to keyword
因此,解释器可以用while True:无限循环替换循环.
Aar*_*all 12
这不太对,
因此,解释器可以用无限循环替换while True:循环.
因为人们仍然可以摆脱循环.但确实else在Python 3中永远不会访问这样的循环子句.而且,简化值查找也使得它的运行速度与while 1Python 2 一样快.
展示一个有点不平凡的while循环的时间差异:
def while1():
x = 0
while 1:
x += 1
if x == 10:
break
def whileTrue():
x = 0
while True:
x += 1
if x == 10:
break
>>> import timeit
>>> min(timeit.repeat(while1))
0.49712109565734863
>>> min(timeit.repeat(whileTrue))
0.756627082824707
>>> import timeit
>>> min(timeit.repeat(while1))
0.6462970309949014
>>> min(timeit.repeat(whileTrue))
0.6450748789939098
为了解释差异,在Python 2中:
>>> import keyword
>>> 'True' in keyword.kwlist
False
但在Python 3中:
>>> import keyword
>>> 'True' in keyword.kwlist
True
>>> True = 'true?'
File "<stdin>", line 1
SyntaxError: can't assign to keyword
由于True是Python 3中的关键字,因此解释器不必查找值以查看是否有人将其替换为其他值.但由于可以分配True给另一个值,解释器每次都必须查找它.
如果你在Python 2中有一个紧凑的,长时间运行的循环,你可能应该使用while 1:而不是while True:.
使用while True:,如果你有你的循环的突破没有条件.
这是一个已有 7 年历史的问题，已经有了一个很好的答案，但该问题中的一个误解（任何答案都没有解决）可能会使其他一些标记为重复的问题感到困惑。
在其他上下文中，Python 的行为就好像 True 等于 1：
>>> True == 1
True
>>> True + True
2
while为什么要区分两者呢？
事实上，while这里根本没有做任何不同的事情。它以与示例完全相同的方式区分1和。True+
这是2.7：
>>> dis.dis('True == 1')
1 0 LOAD_GLOBAL 0 (True)
3 LOAD_CONST 1 (1)
6 COMPARE_OP 2 (==)
9 RETURN_VALUE
>>> dis.dis('True == 1')
1 0 LOAD_GLOBAL 0 (True)
3 LOAD_GLOBAL 0 (True)
6 BINARY_ADD
9 RETURN_VALUE
现在比较一下：
>>> dis.dis('1 + 1')
1 0 LOAD_CONST 1 (2)
3 RETURN_VALUE
它LOAD_GLOBAL (True)为每个发出 a True，优化器无法对全局执行任何操作。因此，出于完全相同的原因，while区分1和。（并且不区分它们，因为优化器不会优化比较。）True+==
现在比较3.6：
>>> dis.dis('True == 1')
1 0 LOAD_CONST 0 (True)
2 LOAD_CONST 1 (1)
4 COMPARE_OP 2 (==)
6 RETURN_VALUE
>>> dis.dis('True + True')
1 0 LOAD_CONST 1 (2)
2 RETURN_VALUE
在这里，它发出LOAD_CONST (True)for 关键字，优化器可以利用它。所以，True + 1 不区分，出于完全相同的原因while True不区分。（并且==仍然无法区分它们，因为优化器不会优化比较。）
同时，如果代码没有经过优化，解释器最终会在所有这三种情况下进行完全相同的True处理。是 的子类，并且从 继承了它的大部分方法，并且内部整数值为 1。因此，无论您是在进行测试（在 3.x 中、在 2.x 中）、比较 ( ) 还是算术( )，无论您使用或 ，都会调用相同的方法。1boolintintTruewhile__bool____nonzero____eq____add__True1