使用 10**9 的成本超过 1000000000？

没有性能成本。考虑一下：

import dis
def foo():
    x = 10**9
    y = 10**9

def bar():
    x = 1000000000
    y = 1000000000

dis.dis(foo)
dis.dis(bar)

收益 率

In [6]: dis.dis(foo)
  5           0 LOAD_CONST               3 (1000000000)
              3 STORE_FAST               0 (x)

  6           6 LOAD_CONST               4 (1000000000)
              9 STORE_FAST               1 (y)
             12 LOAD_CONST               0 (None)
             15 RETURN_VALUE        

In [8]: dis.dis(bar)
  9           0 LOAD_CONST               1 (1000000000)
              3 STORE_FAST               0 (x)

 10           6 LOAD_CONST               1 (1000000000)
              9 STORE_FAST               1 (y)
             12 LOAD_CONST               0 (None)
             15 RETURN_VALUE        

因此，当 Python 编译代码时，它会将 .在运行字节码时，使用 或 之间没有区别。10**9100000000010**91000000000

它更多的是关于可读性和编码风格。通过编写诸如 instead of or 之类的东西，您将使您的代码更短、更易读，因此它的维护和改进会更容易。如果你想在代码中多次使用，作为一种更优雅的方式，你最好在模块的顶层将其用作全局变量，这样更优雅。喜欢：10**9100000000010**9

MY_VARIABLE = 10**9

请注意，即使您不使用全局变量名称并通过代码使用其数值，python 也会假设它是一个常量值，并且不会每次都重新计算它。

例如，正如您在以下字节码中看到的那样，python 将加载常量值（您在第一部分中为 定义了 ），并且不会为此创建新的对象 ¹：ac

>>> def test():
...    a = 10**9
...    b = 1000000000
...    c = 10**9
... 
>>> dis.dis(test)
  2           0 LOAD_CONST               4 (1000000000)
              3 STORE_FAST               0 (a)

  3           6 LOAD_CONST               3 (1000000000)
              9 STORE_FAST               1 (b)

  4          12 LOAD_CONST               5 (1000000000)
             15 STORE_FAST               2 (c)
             18 LOAD_CONST               0 (None)
             21 RETURN_VALUE    

---

_{请注意，python 小整数是单例，python 只会创建它们的一个副本（-5 到 256）。}

经过自我反省，我做了一些时间测量：

>>> import timeit

>>> def f():
...     return 10**9

>>> timeit.timeit(f)
0.13885498046875

>>> def f():
...     return 1000000000

>>> timeit.timeit(f)
0.13900208473205566

使用表达式是有成本的，即由于 Python 预计算常量表达式而产生的性能成本，但在大多数情况下，这种成本不太可能很明显，例如 ，在 等情况下更是如此。10**910**(10**10)