✧ Где живут переменные ✧

🚀 Запускаем

У Путешественника 100 единиц смолы. Функция «тратит» 20, но что напечатает программа снаружи? Запусти и угадай заранее:

resin = 100

def spend():
    resin = 20
    print("внутри:", resin)

spend()
print("снаружи:", resin)

Внутри 20, а снаружи по-прежнему 100. Переменная resin в функции — другая, она просто носит такое же имя. Почему так и как с этим жить — тема урока.

📜 Теория: область видимости

Локальные и глобальные

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

resin = 100

def can_run_domain():
    return resin >= 20     # читаем глобальную

print(can_run_domain())     # → True

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

resin = 100

def spend():
    resin += 20     # Python решил, что resin — локальная, а значения у неё ещё нет

spend()
UnboundLocalError: cannot access local variable 'resin' where it is not associated with a value

Как менять состояние правильно

Есть слово global, которое разрешает функции менять глобальную переменную, но пользоваться им не стоит: такие функции «тайно» зависят от внешнего состояния, и разобраться, кто и где его меняет, становится трудно. Простое правило: передавай значение в функцию параметром, а новое получай через return.

def spend(resin, cost):
    return resin - cost

resin = 100
resin = spend(resin, 20)
print(resin)    # → 80

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

Замыкание: функция, которая помнит

def make_counter(step):
    total = 0

    def count():
        nonlocal total
        total += step
        return total

    return count

a = make_counter(3)
b = make_counter(5)
print(a(), a(), b(), a())    # → 3 6 5 9

Функцию можно объявить внутри другой функции и вернуть наружу. Внутренняя функция сохраняет доступ к переменным внешней, даже когда внешняя уже закончилась: это замыкание. Здесь у каждого счётчика своя total: a и b не мешают друг другу. Слово nonlocal нужно, чтобы внутренняя функция могла изменять переменную внешней (читать можно и так).

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

Порядок поиска имени

Встретив имя, Python ищет его по очереди: внутри текущей функции, в объемлющих функциях, в основной части программы, среди встроенных (print, len…). Это правило называют LEGB (Local, Enclosing, Global, Built-in). Поэтому, если назвать переменную len или sum, ты «закроешь» встроенную функцию с тем же именем: так ошибаются часто, и ошибка бывает неочевидной.

Ещё одна деталь: переменная цикла for остаётся после цикла (в отличие от переменной внутри списка-генератора, которая живёт только внутри него). Поэтому после for k in range(3): pass значение k равно 2.

🧪 Попробуй сам

★★★

🎯 Задача: Счётчики с шагом

25 очков

Напиши функцию make_counter(step), которая возвращает функцию-счётчик. Каждый вызов этого счётчика увеличивает его собственное значение на step и возвращает новое значение. Начальное значение — 0. Счётчики, созданные отдельно, не влияют друг на друга. (Подсказка: пригодится nonlocal.)

Программа читает строку с двумя шагами a b (для счётчиков A и B), затем строку из букв A и B: каждая буква — вызов соответствующего счётчика. После каждого вызова выводится <буква>=<значение>.

Пример. Ввод:

3 5
ABAAB

Вывод:

A=3
B=5
A=6
A=9
B=10

Заготовка (кнопка у блока отправит её в песочницу):

# 1. Функция make_counter(step): внутри — своё значение; внутренняя функция увеличивает его и возвращает

# 2. Прочитай два шага и создай два счётчика

# 3. Для каждой буквы из второй строки вызови нужный счётчик и выведи результат

✅ Что мы узнали

Переменные внутри функции локальные: снаружи их не видно, а присваивание создаёт новую переменную. Читать глобальные можно, менять без global нельзя; лучше передавать значения параметрами и получать результат через return. Внутренняя функция запоминает переменные внешней (замыкание), а nonlocal позволяет их менять. Имена ищутся в порядке LEGB.

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

⟵ Подписываем функции Функция как значение ⟶