У Путешественника 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.
x = 1, def f(): x = 2, f(), print(x)? Запиши ответ, потом проверь.print(total) после создания счётчика. Какую ошибку получишь и почему?make_adder(n), которая возвращает функцию, прибавляющую n к своему аргументу.Напиши функцию 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.
Теперь, когда функции умеют помнить и принимать параметры, самое время передавать в них другие функции.