关于python：对于int来说，比0更快！= 0？


Is >0 faster than !=0 for an int?

哪种测试更快：平等还是不平等？

例如，在一个大的while循环中，条件应该是a>0而不是a!=0？

相关讨论

当问自己一个关于不同操作员之间速度差异的问题时，请使用timeit模块进行测量。他们同样快：

1
2
3
4
5
6
7
8
9
>>> import timeit
>>> timeit.timeit('a > 0', 'a = 1', number=10**7)
0.2486400604248047
>>> timeit.timeit('a > 0', 'a = 0', number=10**7)
0.2411360740661621
>>> timeit.timeit('a != 0', 'a = 1', number=10**7)
0.24765801429748535
>>> timeit.timeit('a != 0', 'a = 0', number=10**7)
0.24990510940551758

这是比较重复1000万次，如果你重新运行上述测试，你会发现时间可能会有所不同，没有一个是明显的赢家。

你应该专注于这里的可读性，而不是速度。简单的整数比较将成为整体执行速度的无限小部分，即使在循环中也是如此。

相关讨论

如果我们谈论的是a是int，那么此时我的机器上的等式检查比大于检查要快一点。您可以使用timeit模块快速检查自己：

1
2
3
4
5
6
7
8
9
10
>>> for s in 'a = 2', 'a = 0', 'a = -2':
        timeit('a != 0', s)
        timeit('a > 0', s)

0.06030992519848155
0.06666935212976455
0.053299842422489974
0.06516424110179742
0.05866621696540619
0.06685335186756447

但是，这些数字与另一个数字非常接近。所以你应该从这个答案中拿出一件事：没关系。

这些东西都是微观优化。微优化很少对应用程序的实际性能产生任何影响。应用程序中有数千个其他部分更有可能对性能产生更大影响，使这种差异可以忽略不计。如果您实际分析了应用程序并确认代码的这一部分是导致应用程序性能下降的瓶颈，那么您应该只关心这些事情。但对于这个特殊的代码，我怀疑情况会是如此。

所以，请不要理会这些微小的差异，而只是使用更有意义的东西：考虑到这两个检查具有不同的语义含义(数字不等于零，或数字大于零)，选择一个你真的打算检查一下。

相关讨论

对我来说，timeit并没有表现出任何明显的差异(假设你正在使用整数)......

1
2
3
4
5
6
7
8
>>> timeit.timeit('1 > 0')
0.031796932220458984
>>> timeit.timeit('1 != 0')
0.03249096870422363
>>> timeit.timeit('1 > 0')
0.03250718116760254
>>> timeit.timeit('1 != 0')
0.031616926193237305

正如关于这个问题的评论所述，你应该专注于最有意义的运算符，而不是关注哪个运算符是最快的。如果您的意思是"在a大于0"时执行此操作而不是使用>。进行这种比较所花费的时间对于整个运行时来说将是一个非常小的贡献因素，因此可能不值得担心哪个运算符更快...

我认为这个有点沉重的测试程序显示在字符和整数比较的情况下基本没有区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import string
def numericgtmostfail():
    for i in range(100):
        x= i > 99
    return x

def numericgtmostsucceed():
    for i in range(100):
        x= i > 1
    return x

def numericnemostsucceed():
    for i in range(100):
        x= i != 99
    return x

def numericnemostfail():
    for i in range(100):
        x= i != i
    return x

def chgtmostfail():
    for s in (string.lowercase * 4)[0:100]:
        x = s > 'y'
    return x

def chgtmostsucceed():
    for s in (string.lowercase * 4)[0:100]:
        x = s > 'a'
    return x

def chnemostfail():
    for s in (string.lowercase * 4)[0:100]:
        x = s != s
    return x

def chnemostsucceed():
    for s in (string.lowercase * 4)[0:100]:
        x = s != 'a'
    return x

if __name__ == '__main__':
    import timeit
    print(timeit.timeit("numericgtmostfail()", setup="from __main__ import numericgtmostfail"))
    print(timeit.timeit("numericgtmostsucceed()", setup="from __main__ import numericgtmostsucceed"))
    print(timeit.timeit("numericnemostsucceed()", setup="from __main__ import numericnemostsucceed"))
    print(timeit.timeit("numericnemostfail()", setup="from __main__ import numericnemostfail"))
    print(timeit.timeit("chgtmostfail()", setup="from __main__ import chgtmostfail"))
    print(timeit.timeit("chgtmostsucceed()", setup="from __main__ import chgtmostsucceed"))
    print(timeit.timeit("chnemostsucceed()", setup="from __main__ import chnemostsucceed"))
    print(timeit.timeit("chnemostfail()", setup="from __main__ import chnemostfail"))

这是你的计划的瓶颈吗？只有答案是肯定的，你才会担心。此外，没有任何东西可以说在任何操作系统或任何类型中都可以更快。

为了好玩，我定时while循环：

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/python
import time

a = 1000000
t0 = time.time()
while(a != 0):
    a = a - 1
t1 = time.time()

total = t1-t0
print total

和：

a > 0给出：

0.12652015686

a != 0给出：

0.111998081207

对于计时，请检查：我如何计算代码段以使用Pythons timeit测试性能？

但是，使用timeit，正如Martijn Pieters建议的那样(在Python 2.7中获取执行代码块的时间)，如下所示：

1
2
3
4
5
6
7
8
9
#!/usr/bin/python

import timeit
a = 1000000
start_time = timeit.default_timer()
while(a != 0):
    a = a - 1
elapsed = timeit.default_timer() - start_time
print elapsed

给了a > 0：

0.10852098465

对于a != 0：

0.108459949493

看两种时序方法的不同之处！

相关讨论