Question

所以我一直看到人们编写代码，当他们希望看到给定值的平方版本时，他们会写出x * x而不是x ** 2。在这两个点之间是否有很大的效率重叠，python中的给定函数不仅仅是使用，还是只是一个风格点？我宁愿使用**操作符，但是如果它会导致巨大的失误，我应该做十亿次操作，过多我知道，我有点想知道。此外，如果我在一个接管另一个的操作的数量级错误，我也想对此进行纠正。即如果**比x * x更有效，那么我也想知道为什么。

Answer 1

我不同意g.d.d.c，乘法要快得多！

"""Evaluating the difference in execution time between n*n and n**2"""

from time import time

n = 2
t = time()
for i in range(5000000):
    n**2
print("Time for n**2:\t%0.3f" % (time()-t))
t = time()
for i in range(5000000):
    n*n
print("Time for n*n:\t%0.3f" % (time()-t))


def test(n):
    """
    Difference in execution time between n*n and n**2
    within function scope.
    """
    t = time()
    for i in range(5000000):
        n**2
    print("Time for n**2:\t%0.3f" % (time()-t))
    t = time()
    for i in range(5000000):
        n*n
    print("Time for n*n:\t%0.3f" % (time()-t))

test(n)

结果：

Time for n**2: 2.324496030807495
Time for n*n:  0.5879969596862793
Time for n**2: 2.0771241188049316
Time for n*n:  0.2894318103790283

您可以看到乘法在函数外的速度快4倍，在函数中速度快7倍。我无法解释这两个测试之间的区别，我不确定n * n和n ** 2之间的区别，但它可能与Python是一种解释性语言的事实有关，后者的处理需要更多的时间，即使处理器操作非常相似，如gddc所示。

Answer 2

实际上，这两者在总成本上可能非常相似：

>>> def s1(x):
...   return x * x
...
>>>
>>> def s2(x):
...   return x ** 2
...
>>>
>>> from dis import dis
>>>
>>> dis(s1)
  2           0 LOAD_FAST                0 (x)
              3 LOAD_FAST                0 (x)
              6 BINARY_MULTIPLY
              7 RETURN_VALUE
>>> dis(s2)
  2           0 LOAD_FAST                0 (x)
              3 LOAD_CONST               1 (2)
              6 BINARY_POWER
              7 RETURN_VALUE
>>>

我认为您可能过早地进行优化，即使是数百万或数十亿次迭代也是如此。除非您已将此视为瓶颈，否则只需使用最适合您的内容。

并且，为了完整起见，timeit结果：

>>> timeit.Timer("s1(10)", 'from __main__ import s1').timeit(100000)
0.0186597650628606
>>> timeit.Timer("s2(10)", 'from __main__ import s2').timeit(100000)
0.018789616358585448

这似乎表明{100}次迭代中x * x 的速度更快。

* vs **为2次幂操作

2 个答案: