Question

我的理解是，当Python解析函数的源代码时，它会将其编译为字节码，但在调用函数之前不会运行此字节码（这就是为什么函数中的非法变量名不会抛出异常的原因）除非你打电话给这个函数。）

默认参数在函数初始设置期间未实例化，但仅在第一次调用函数时，无论是否提供参数。默认参数的相同实例用于所有将来的调用，可以通过使用可变类型作为默认参数来看到。

但是，如果我们将函数放在另一个函数中，那么每次调用外部函数时，现在似乎都会重新实例化默认参数，如下面的代码所示：

def f(x):
    def g(y, a=[]):
        a.append(y)
        return a

    for y in range(x, x + 2):
        print('calling g from f:', g(y))
    return g(y + 1)

for x in range(2):
    print('calling f from module scope:', f(x))

打印出来

calling g from f: [0]
calling g from f: [0, 1]
calling f from module scope: [0, 1, 2]
calling g from f: [1]
calling g from f: [1, 2]
calling f from module scope: [1, 2, 3]

这是否意味着每次调用f时，g的字节码都会重建？这种行为似乎是不必要的，并且很奇怪，因为f（包括g？）的字节码只构建一次。或者它可能只是g的默认参数，每次调用f时都会重新验证？

Answer 1

使用内部函数的现有字节码重建内部函数。使用dis很容易看到。

>>> import dis
>>> def make_func():
...     def my_func():
...         pass
...     return my_func
>>> dis.dis(make_func.__code__)
  3       0 LOAD_CONST               1 (<code object my_func at [...]", line 3>)
          3 MAKE_FUNCTION            0
          6 STORE_FAST               0 (my_func)

  5       9 LOAD_FAST                0 (my_func)
         12 RETURN_VALUE

现在，如果你这样做：

>>> f1 = make_func()
>>> f2 = make_func()
>>> f1 is f2
False
>>> f1.__code__ is f2.__code__
True

Answer 2

第一个误解：“当Python解析函数的源代码时，它会将其编译为字节码，但在调用函数之前不会运行此字节码（这就是为什么函数中的非法变量名称不会抛出异常，除非你叫这个功能）。“要明确的是，你的误解是“除非你调用函数，否则函数中的非法变量名称不会抛出异常”。在执行该函数之前，不会捕获未分配的名称。

看看这个简单的测试：

In [1]: def g(a):
   ...:     123onetwothree = a
  File "<ipython-input-5-48a83ac30c7b>", line 2
    123onetwothree = a

第二个误解：“在函数的初始设置期间，默认参数不实例化，但仅在第一次调用函数时...”。这是不正确的。

In [7]: def f(x=[]):
   ...:     print(x)
   ...:     x.append(1)
   ...:     print(x)
   ...:
   ...:

In [8]: f.__defaults__
Out[8]: ([],)

In [9]: f()
[]
[1]

In [10]: f.__defaults__
Out[10]: ([1],)

In [11]:

至于您的示例，每次运行f时，默认参数都会重新实例化，因为您在g 中定义了f。考虑它的最好方法是将def语句视为function对象的构造函数，以及默认参数，例如此构造函数的参数。每次运行def some_function时，就像重新调用构造函数一样，函数重新定义就好像在g = function(a=[])的正文中编写了f一样。

回应评论

In [11]: def f(x=h()): pass
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-11-ecbb4a9f8673> in <module>()
----> 1 def f(x=h()): pass

NameError: name 'h' is not defined

Answer 3

只需使用f查看dis的字节码：

dis(f)
  2           0 BUILD_LIST               0
              3 LOAD_CONST               1 (<code object g at 0x7febd88411e0, file "<ipython-input-21-f2ef9ebb6765>", line 2>)
              6 LOAD_CONST               2 ('f.<locals>.g')
              9 MAKE_FUNCTION            1
             12 STORE_FAST               1 (g)

  6          15 SETUP_LOOP              46 (to 64)
             18 LOAD_GLOBAL              0 (range)
             21 LOAD_FAST                0 (x)
             24 LOAD_FAST                0 (x)
             27 LOAD_CONST               3 (2)
             30 BINARY_ADD
             31 CALL_FUNCTION            2 (2 positional, 0 keyword pair)
             34 GET_ITER
        >>   35 FOR_ITER                25 (to 63)
             38 STORE_FAST               2 (y)

^{（为简洁起见）}

为g加载的代码对象：

3 LOAD_CONST               1 (<code object g at 0x7febd88411e0, file "<ipython-input-21-f2ef9ebb6765>", line 2>)

不包含任何可变结构，它只包含可执行代码和其他不可变信息。你也可以看看它：

dis(f.__code__.co_consts[1])
  3           0 LOAD_FAST                1 (a)
              3 LOAD_ATTR                0 (append)
              6 LOAD_FAST                0 (y)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 POP_TOP

  4          13 LOAD_FAST                1 (a)
             16 RETURN_VALUE

每次调用f时，都会调用MAKE_FUNCTION，从已存在的字节代码重新创建函数。

Python

3 个答案: