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

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

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

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

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

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

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

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

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

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

Упрощённо это можно представить так:

import timeit

value = 10

def global_sum(n):
    total = 0
    for _ in range(n):
        total += value
    return total

def local_sum(n):
    value_local = value
    total = 0
    for _ in range(n):
        total += value_local
    return total

print(timeit.timeit("global_sum(1000)", globals=globals(), number=10000))
print(timeit.timeit("local_sum(1000)", globals=globals(), number=10000))

В global_sum чтение value выполняется как доступ к глобальному имени. В local_sum после присваивания используется локальная переменная, доступ к которой обычно дешевле. Точные результаты зависят от версии Python и оборудования, поэтому пример демонстрирует способ проверки, а не гарантированный коэффициент ускорения.

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

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

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

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

В обработчике миллионов коротких записей профилировщик показал, что основное время уходит не на вычисление, а на повторные вызовы одной функции, получаемой из глобального пространства имён. Команда рассмотрела три варианта: оставить код без изменений ради простоты, заменить функцию локальным псевдонимом внутри обработчика или переписать алгоритм целиком.

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

Это решение дало локальное ускорение без изменения внешнего поведения, но его оставили только после профилирования. Если бы вызываемая функция выполняла сложный ввод-вывод или тяжёлое вычисление, экономия на поиске имени, вероятно, была бы пренебрежимо малой.

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

Всегда ли локальная переменная быстрее глобальной в любой версии Python?

Нет. Это типичное свойство реализации CPython, а не универсальная гарантия языка Python. Оптимизирующие механизмы конкретной версии, в том числе специализация байткода, могут сократить разницу. Кроме того, на другом интерпретаторе внутренний механизм может быть иным, поэтому переносить вывод без измерений нельзя.

Почему локальное присваивание глобального объекта может изменить поведение программы?

Локальная переменная получает ссылку на объект в момент присваивания. Если после этого глобальное имя переназначить на другой объект, локальная переменная продолжит ссылаться на прежний объект. Поэтому локальный псевдоним — не только потенциальная оптимизация доступа, но и фиксация конкретного значения на время выполнения функции.

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

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