Как закрытия реализованы?

Я думаю, довольно очевидно, что происходит, когда вы думаете о i как имя , а не какое-то значение . Ваша лямбда-функция делает что-то вроде «взять x: найти значение i, вычислить i ** x» ... поэтому, когда вы действительно запускаете функцию, она ищет i только тогда , поэтому i равно 4 .

Вы также можете использовать текущий номер, но вы должны заставить Python привязать его к другому имени:

def makeActions():
    def make_lambda( j ):
        return lambda x: j * x # the j here is still a name, but now it wont change anymore

    acts = []
    for i in range(5):
        # now you're pushing the current i as a value to another scope and 
        # bind it there, under a new name
        acts.append(make_lambda(i))
    return acts

Это может показаться запутанным, потому что вас часто учат, что переменная и ее значение - это одно и то же, что является правда, но только для языков, которые действительно используют переменные. В Python нет переменных, но есть имена.

По поводу вашего комментария, на самом деле я могу проиллюстрировать это немного лучше:

i = 5 
myList = [i, i, i] 
i = 6
print(myList) # myList is still [5, 5, 5].

Вы сказали, что изменили i на 6 , но это не то, что на самом деле произошло: i = 6 означает «у меня есть значение, 6 , и я хочу назвать его i ».Тот факт, что вы уже использовали i в качестве имени, не имеет значения для Python, он просто переназначит имя , а не изменит его значение (это работает только с переменными ).

Можно сказать, что в myList = [i, i, i] любое значение i , на которое в настоящее время указывает (число 5), получает три новых имени: mylist [0], мой список [1], мой список [2] . То же самое происходит, когда вы вызываете функцию: аргументам присваиваются новые имена. Но это, вероятно, противоречит любой интуиции о списках ...

Это может объяснить поведение в примере: вы назначаете mylist [0] = 5 , mylist [1] = 5 , mylist [2] = 5 - неудивительно, что они не меняются при переназначении i . Если i был чем-то отключаемым, например списком, то изменение i отразилось бы и на всех записях в myList , потому что у вас просто разных имен за такое же значение !

Тот простой факт, что вы можете использовать mylist [0] слева от = , доказывает, что это действительно имя. Мне нравится называть = оператор присвоения имени : он берет имя слева и выражение справа, затем оценивает выражение (вызовите функцию, найдите значения за names), пока он не получит значение и, наконец, не даст имя значению. Это ничего не меняет .

Для комментария Марка о компиляции функций:

Что ж, ссылки (и указатели) имеют смысл только тогда, когда у нас есть какая-то адресуемая память. Значения хранятся где-то в памяти, и ссылки ведут вас туда. Использование ссылки означает переход к этому месту в памяти и что-то с ним делать. Проблема в том, что ни одна из этих концепций не используется Python!

В виртуальной машине Python нет понятия памяти - значения плавают где-то в пространстве , а имена - это маленькие теги, связанные с ними (маленькой красной строкой). Имена и ценности существуют в разных мирах!

Это имеет большое значение при компиляции функции. Если у вас есть ссылки, вы знаете место в памяти объекта, на который вы ссылаетесь. Затем вы можете просто заменить ссылку на это местоположение. С другой стороны, имена не имеют местоположения, поэтому все, что вам нужно сделать (во время выполнения), - это следовать за этой маленькой красной строкой и использовать все, что находится на другом конце. Вот так Python компилирует функции: Где всякий раз, когда в коде есть имя, он добавляет инструкцию, которая выясняет, что это имя означает.

Таким образом, в основном Python полностью компилирует функции, но имена компилируются как поиск во вложенных пространствах имен, не как своего рода ссылка на память.

Когда вы используете имя, компилятор Python пытается выяснить, какому пространству имен оно принадлежит. Это приводит к инструкции по загрузке этого имени из найденного пространства имен.

Это возвращает вас к исходной проблеме: в лямбда x: x ** i , i компилируется как поиск в пространстве имен makeActions (потому что там использовалось i ). Python не знает, и не заботится о стоящем за ним значении (это даже не обязательно должно быть действительное имя). Тот, который запускает код i , просматривается в исходном пространстве имен и дает более или менее ожидаемое значение.