假设我有一个包含很多被乘数(小表达式)的乘法表达式
expression = a*b*c*d*....*w
例如 c 是 (x-1),d 是 (y**2-16),k 是 (xy-60)..... x,y 是数字
我知道 c、d、k、j 可能为零
我编写表达式的顺序对于更快的评估是否重要?
是写 cdkj....*w 更好,还是不管我写的顺序如何,python 都会评估所有表达式?
最佳答案
Python v2.6.5 不检查零值。
def foo():
a = 1
b = 2
c = 0
return a * b * c
>>> import dis
>>> dis.dis(foo)
2 0 LOAD_CONST 1 (1)
3 STORE_FAST 0 (a)
3 6 LOAD_CONST 2 (2)
9 STORE_FAST 1 (b)
4 12 LOAD_CONST 3 (3)
15 STORE_FAST 2 (c)
5 18 LOAD_FAST 0 (a)
21 LOAD_FAST 1 (b)
24 BINARY_MULTIPLY
25 LOAD_FAST 2 (c)
28 BINARY_MULTIPLY
29 RETURN_VALUE
更新:我测试了Baldur的表达式,Python 可以而且将会优化涉及常量表达式的代码。 奇怪 是 test6
没有优化。
def test1():
return 0 * 1
def test2():
a = 1
return 0 * a * 1
def test3():
return 243*(5539**35)*0
def test4():
return 0*243*(5539**35)
def test5():
return (256**256)*0
def test6():
return 0*(256**256)
>>> dis.dis(test1) # 0 * 1
2 0 LOAD_CONST 3 (0)
3 RETURN_VALUE
>>> dis.dis(test2) # 0 * a * 1
5 0 LOAD_CONST 1 (1)
3 STORE_FAST 0 (a)
6 6 LOAD_CONST 2 (0)
9 LOAD_FAST 0 (a)
12 BINARY_MULTIPLY
13 LOAD_CONST 1 (1)
16 BINARY_MULTIPLY
17 RETURN_VALUE
>>> dis.dis(test3) # 243*(5539**35)*0
9 0 LOAD_CONST 1 (243)
3 LOAD_CONST 5 (104736434394484...681759461305771899L)
6 BINARY_MULTIPLY
7 LOAD_CONST 4 (0)
10 BINARY_MULTIPLY
11 RETURN_VALUE
>>> dis.dis(test4) # 0*243*(5539**35)
12 0 LOAD_CONST 5 (0)
3 LOAD_CONST 6 (104736433252667...001759461305771899L)
6 BINARY_MULTIPLY
7 RETURN_VALUE
>>> dis.dis(test5) # (256**256)*0
15 0 LOAD_CONST 4 (0L)
3 RETURN_VALUE
>>> dis.dis(test6) # 0*(256**256)
18 0 LOAD_CONST 1 (0)
3 LOAD_CONST 3 (323170060713110...853611059596230656L)
6 BINARY_MULTIPLY
7 RETURN_VALUE
简而言之,如果表达式包含变量,则顺序无关紧要。一切都会被评估。
关于python - 如果找到零,python 乘法表达式的计算速度会更快吗?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/3264345/