Время создания для изменяемых аргументов замыканий по умолчанию в Python

Первое заблуждение: «когда 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, это похоже на вызов конструктора снова и снова, и функция переопределяется, как если бы в теле f было записано g = function(a=[]).

В ответ на комментарий

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

Внутренняя функция перестраивается с использованием существующего байт-кода для внутренней функции. Это легко увидеть, используя 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

Просто посмотрите на байт-код для 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, который заново создает функцию из уже существующего байтового кода.