Краткий ответ

Причина — позднее связывание переменных в замыканиях. Функции запоминают не текущее значение переменной цикла, а ссылку на общую ячейку окружения и читают её значение только при вызове, когда цикл уже завершён.

Чтобы сохранить значение на момент создания обработчика, используют аргумент по умолчанию, фабричную функцию или functools.partial.

Исторический контекст

Замыкания появились как механизм лексической области видимости: вложенная функция может обращаться к переменным внешней функции даже после завершения её выполнения. Это удобно для создания обработчиков с сохранённым контекстом без явного класса или отдельного объекта состояния.

Python сохраняет в замыкании связь с переменной, а не её моментальный снимок. Такой подход поддерживает динамическое чтение состояния внешней переменной, но создаёт известный эффект позднего связывания при формировании функций в цикле или comprehension.

Постановка проблемы

Если обработчики создаются в цикле, а выполняются позже — например, после получения событий, ответа пользователя или завершения задачи, — все они могут обратиться к одной и той же переменной цикла. К моменту вызова в этой переменной обычно находится последнее значение.

Неверное решение приводит не к ошибке Python, а к логически неправильному поведению: кнопки, маршруты или задачи начинают обрабатываться так, будто все они относятся к последнему элементу.

Подробное решение

У каждой функции есть замыкание — набор ссылок на внешние переменные, используемые функцией. Для переменной цикла создаётся ячейка окружения; функции, созданные в одной области, могут ссылаться на одну и ту же ячейку.

При создании функции выражение с переменной не вычисляется немедленно. Оно вычисляется при вызове функции. Поэтому после завершения цикла все обработчики читают итоговое содержимое общей ячейки.

handlers = [lambda: item for item in ["a", "b", "c"]]

print([handler() for handler in handlers])

fixed = [lambda item=item: item for item in ["a", "b", "c"]]
print([handler() for handler in fixed])

Первый результат — ['c', 'c', 'c'], потому что все функции читают одну переменную после завершения цикла. Во втором варианте значение item вычисляется при создании каждой функции и сохраняется как значение её аргумента по умолчанию, поэтому результат — ['a', 'b', 'c'].

Важно не смешивать две особенности. В Python 3 переменная спискового включения не протекает во внешнюю область видимости, но внутри самого включения функции всё равно могут захватить одну переменную цикла. Отсутствие утечки имени наружу не означает копирования значения для каждой функции.

Фабричная функция решает задачу через отдельную область видимости для каждого вызова. functools.partial удобен, когда обработчик уже существует и нужно заранее привязать к нему аргумент. Аргумент по умолчанию лаконичен, но может скрывать намерение и требует осторожности для изменяемых объектов.

Ситуация из практики

В веб-приложении для списка заказов создавали обработчики кнопок отмены. Каждый обработчик должен был отправлять идентификатор своего заказа, но все кнопки отправляли идентификатор последнего заказа в списке.

Рассматривались три варианта. Аргумент по умолчанию исправлял проблему минимальным изменением, но связывал технический приём с интерфейсом функции. functools.partial был выразителен для уже готового обработчика, однако добавлял отдельный объект-обёртку. Фабрика обработчиков явно показывала границу области видимости и позволяла удобно добавить дополнительные параметры.

Выбрали фабричную функцию, потому что обработчик должен был хранить не только идентификатор заказа, но и объект журнала. Каждый вызов фабрики создавал собственное замыкание, поэтому кнопки стали передавать правильные идентификаторы, а расширение логики не потребовало неочевидных аргументов по умолчанию.

Что кандидаты часто упускают

Почему переменная спискового включения не исчезает из замыкания, хотя не видна после включения?

Списковое включение в Python 3 выполняется в отдельной неявной области видимости, поэтому его переменная не загрязняет внешнюю область. Однако функции, созданные внутри этой области, удерживают нужную ячейку окружения через замыкание. Область не становится недоступной для сборки, пока на неё ссылаются созданные функции.
Изменится ли результат замыкания, если внешнюю переменную изменить после создания функции?

Да, если функция захватывает переменную через nonlocal или обращается к изменяемой ячейке внешней области. При вызове она прочитает текущее значение этой ячейки, а не обязательно то, которое было при создании функции. Это и есть практическое проявление позднего связывания; для фиксации значения применяют аргумент по умолчанию или отдельную область видимости.
Почему немедленный вызов функции внутри comprehension обычно не демонстрирует эту проблему?

При немедленном вызове функция выполняется до перехода цикла к следующему элементу. В этот момент переменная цикла ещё содержит текущее значение, поэтому результат вычисляется правильно.

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