Python 编译器和函数内部定义的常量

Question

Python 编译器是否识别函数中定义的常量，以便无论随后在代码中调用该函数多少次，它只计算一次它们的值？

例如，

def f():
    x = [ 1, 2, 3, 4 ]
    # stuff

for i in range( 100 ):
    f()

x 是否会被重新计算 100 次 f() 被调用？

在使用它们的函数之外定义常量并不总是可能的，我很好奇 Python 是否在这些情况下支持你。

Answer 1

（请注意，这适用于 CPython，在其他实现中可能会有所不同）

Python 代码被解析并编译成字节码。您可以查看与dis 模块一起使用的说明。

>>> def f(x):
...     x = [1, 2, 3, 4]
>>> dis.dis(f)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               3 (3)
              6 LOAD_CONST               4 (4)
              8 BUILD_LIST               4
             10 STORE_FAST               0 (x)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

>>> print(dis.Bytecode(f).info())
Name:              f
Filename:          <stdin>
Argument count:    1
Kw-only arguments: 0
Number of locals:  1
Stack size:        4
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: None
   1: 1
   2: 2
   3: 3
   4: 4
Variable names:
   0: x

如您所见，整数字面量是常量，但每次都必须构建列表。

这是一个相对较快的操作（可能比查找全局更快，但时间仍然可以忽略不计）

如果您有一个使用元组的函数g，则将其作为常量加载：

>>> def g(x):
...     x = (1, 2, 3, 4)
>>> dis.dis(g)
  2           0 LOAD_CONST               5 ((1, 2, 3, 4))
              2 STORE_FAST               0 (x)
              4 LOAD_CONST               0 (None)
              6 RETURN_VALUE
>>> print(dis.Bytecode(g).info())
Name:              g
Filename:          <stdin>
Argument count:    1
Kw-only arguments: 0
Number of locals:  1
Stack size:        4
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: None
   1: 1
   2: 2
   3: 3
   4: 4
   5: (1, 2, 3, 4)
Variable names:
   0: x

但这似乎是过早优化的情况。

可以找到为函数存储的常量function.__code__.co_consts。

>>> g.__code__.co_consts
(None, 1, 2, 3, 4, (1, 2, 3, 4))

---

每次都必须构建一个新列表的原因是，如果列表被更改，它不会影响每次加载的列表。

如果不是常量列表，元组优化就会消失。

>>> def h(x):
...     x = (1, 2, 3, x)
>>> dis.dis(h)
  2           0 LOAD_CONST               1 (1)
              2 LOAD_CONST               2 (2)
              4 LOAD_CONST               3 (3)
              6 LOAD_FAST                0 (x)
              8 BUILD_TUPLE              4
             10 STORE_FAST               0 (x)
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE
>>> print(dis.Bytecode(h).info())
Name:              h
Filename:          <stdin>
Argument count:    1
Kw-only arguments: 0
Number of locals:  1
Stack size:        4
Flags:             OPTIMIZED, NEWLOCALS, NOFREE
Constants:
   0: None
   1: 1
   2: 2
   3: 3
Variable names:
   0: x

Answer 2

简答：对于列表，它没有。

如果我们用dis检查编译后的中间代码，我们看到：

>>> dis.dis(f)
  2           0 LOAD_CONST               1 (1)
              3 LOAD_CONST               2 (2)
              6 LOAD_CONST               3 (3)
              9 LOAD_CONST               4 (4)
             12 BUILD_LIST               4
             15 STORE_FAST               0 (x)
             18 LOAD_CONST               0 (None)
             21 RETURN_VALUE

如您所见，程序首先将常量1 加载到4 并将它们压入堆栈，然后用这些常量构造一个列表，这意味着它每次都构造一个列表强>.

如果列表没有变异，我建议在函数外定义常量：

some_constant = [1, 2, 3, 4]
def f():
    # use some_constant
    # ...
    pass