Области видимости и правило LEGB в Python
Обновлено:
1. Что такое область видимости
В программе одновременно может существовать множество имён:
price
user_name
result
calculate_total
len
print
Python должен понимать, где искать имя, когда встречает его в коде.
Для этого используются области видимости:
Local
Enclosing
Global
Built-in
Их часто объединяют в правило:
LEGB
Поиск имени выполняется в таком порядке:
Local → Enclosing → Global → Built-in
В этой теме подробно разберём:
- локальную область —
Local; - глобальную область —
Global; - встроенную область —
Built-in.
Область Enclosing пока только запомним. Она появляется при работе с вложенными функциями и будет подробно рассмотрена позже.
Глобальная область видимости
2. Глобальное имя доступно внутри функции
Создадим переменную вне функции:
product_price = 300
def print_product_price():
print('price:', product_price)
print('local:', dir())
print_product_price()
print('global:', dir())
Переменная:
product_price
создана в глобальной области видимости.
Функция может обратиться к ней:
print(product_price)
потому что Python сначала ищет имя в локальной области функции, а если его там нет — продолжает поиск дальше.
При этом:
dir()
внутри функции покажет имена именно её текущей локальной области.
В данном примере собственных локальных имён у функции нет, поэтому результат может быть:
[]
Глобальная переменная product_price доступна функции, но от этого она не становится локальной.
3. Что находится в глобальной области
После определения:
product_price = 300
def print_product_price():
...
в глобальной области существуют, среди прочего, имена:
product_price
print_product_price
То есть имя функции тоже создаётся в той области, где выполняется def.
Локальная область видимости
4. Имя, созданное внутри функции
def calculate_total():
total_price = 300
print('total:', total_price)
print('local:', dir())
calculate_total()
Переменная:
total_price
создана внутри функции.
Она относится к локальной области этой функции.
dir() внутри неё покажет:
['total_price']
5. Из глобальной области нельзя обратиться к локальному имени функции
После завершения функции:
def calculate_total():
total_price = 300
calculate_total()
print(total_price)
возникнет:
NameError
Имя:
total_price
существовало только в локальной области функции.
Глобальная область не может просто «зайти внутрь» функции и забрать оттуда её локальное имя.
return и область видимости
6. return возвращает объект, а не локальное имя
Рассмотрим:
def calculate_total():
total_price = 300
return total_price
Функция возвращает объект, на который ссылается локальное имя:
total_price
Но само локальное имя наружу не переносится.
Поэтому:
calculate_total()
print(total_price)
всё равно приведёт к NameError.
Чтобы сохранить возвращённый объект, в глобальной области нужно создать новое имя:
result = calculate_total()
print(result)
Теперь:
result
— глобальное имя, которое ссылается на возвращённый объект.
Можно посмотреть идентификаторы:
def calculate_total():
total_price = 300
print('local id:', id(total_price))
return total_price
result = calculate_total()
print('global id:', id(result))
В обоих случаях мы можем получить одинаковый id, потому что функция вернула ссылку на тот же объект.
При этом имена разные:
внутри функции → total_price
снаружи → result
Каждая функция имеет собственную локальную область
7. Две функции — две разные локальные области
def create_product_price():
product_price = 1500
print('first local:', dir())
def create_delivery_price():
delivery_price = 300
print('second local:', dir())
create_product_price()
create_delivery_price()
print('global:', dir())
У первой функции есть своя локальная область:
product_price
У второй:
delivery_price
Глобальная область — третья отдельная область, в которой находятся имена самих функций.
8. Одна функция не видит локальные имена другой
def create_product_price():
product_price = 1500
def print_product_price():
print(product_price)
create_product_price()
print_product_price()
Вторая функция не может получить локальное имя первой.
При выполнении:
print(product_price)
Python ищет имя для функции print_product_price():
Local
↓
Enclosing
↓
Global
↓
Built-in
Локальная переменная другой функции в этот поиск вообще не входит.
Поэтому возникнет:
NameError
Одинаковые имена в разных областях
9. Локальное имя может скрыть глобальное
status = 'global'
def print_status():
status = 'local'
print('inside:', status)
print('inside id:', id(status))
print_status()
print('outside:', status)
print('outside id:', id(status))
Результат:
inside: local
outside: global
Здесь существуют два разных имени status:
Global → status = 'global'
Local → status = 'local'
Локальное имя скрывает глобальное внутри функции.
Такое явление называют:
shadowing
или:
затенение имени
10. Изменение локальной переменной
Если переменная создана внутри функции, её можно переназначать внутри этой же локальной области:
counter = 100
def increase_counter():
counter = 10
counter += 1
print(counter)
increase_counter()
print(counter)
Результат:
11
100
Операция:
counter += 1
работает с локальным counter.
Глобальное значение:
counter = 100
не изменяется.
UnboundLocalError
11. Почему x += 1 может привести к ошибке
Рассмотрим:
counter = 100
def increase_counter():
counter += 1
print(counter)
increase_counter()
Возникнет:
UnboundLocalError
Причина связана с присваиванием:
counter += 1
Эта операция по смыслу требует:
- получить текущее значение
counter; - прибавить
1; - присвоить результат имени
counter.
Но поскольку внутри функции есть присваивание имени counter, Python рассматривает это имя как локальное для всей функции.
Получается, функция пытается сначала прочитать локальный counter, которому ещё ничего не присвоено.
Отсюда возникает UnboundLocalError.
12. Чтение глобального значения разрешено
Если присваивания локальному имени нет:
counter = 100
def print_counter():
print(counter)
print_counter()
функция спокойно найдёт глобальный counter.
То есть:
прочитать глобальное значение → можно
Но простое присваивание одноимённой переменной внутри функции создаёт локальное имя.
Для явного переназначения глобального имени существует ключевое слово:
global
Его возможности будут рассмотрены отдельно.
На практике функции обычно стараются проектировать так, чтобы они получали изменяемые данные через параметры и возвращали результат, а не изменяли глобальные переменные без необходимости.
13. UnboundLocalError относится к NameError
Можно посмотреть цепочку наследования:
print(UnboundLocalError.mro())
Среди классов будет:
UnboundLocalError
NameError
Exception
...
UnboundLocalError — более конкретная разновидность ошибки, связанной с обращением к локальному имени до того, как оно получило значение.
Присваивание ниже по функции
14. Python определяет локальные имена для всей функции
Рассмотрим:
value = 100
def print_value():
print(value)
value = 50
print_value()
Может показаться, что первый:
print(value)
должен взять глобальное значение 100, потому что локальное присваивание находится ниже.
Но возникнет:
UnboundLocalError
Причина в том, что наличие присваивания:
value = 50
делает value локальным именем функции.
Это определяется для всей функции, а не только начиная со строки присваивания.
Поэтому первый:
print(value)
пытается прочитать локальное имя, которому значение ещё не присвоено.
15. Если убрать локальное присваивание
value = 100
def print_value():
print(value)
print_value()
Результат:
100
Теперь локального value нет, поэтому Python продолжает поиск в глобальной области.
Порядок поиска имён
16. Правило LEGB
Когда Python встречает имя, он ищет его в следующем порядке:
L → Local
E → Enclosing
G → Global
B → Built-in
То есть:
1. Локальная область функции
2. Область внешней функции
3. Глобальная область модуля
4. Встроенная область Python
Если имя нигде не найдено, обычно возникает:
NameError
Локальная → глобальная → встроенная
17. Пример с именем len
Для учебной демонстрации используем имя встроенной функции:
len
В настоящей программе создавать собственные переменные с таким названием не следует.
len = 7
def show_value():
len = 50
print(len)
show_value()
Результат:
50
Python нашёл имя в локальной области и остановил поиск.
18. Если локального имени нет
len = 7
def show_value():
print(len)
show_value()
Результат:
7
Поиск:
Local → нет
Global → найдено
На этом поиск заканчивается.
19. Если глобального имени тоже нет
def show_value():
print(len)
show_value()
Теперь Python ищет:
Local → нет
Enclosing → нет
Global → нет
Built-in → найдено
Будет выведен объект встроенной функции len примерно в таком виде:
<built-in function len>
Именно благодаря встроенной области мы можем писать:
len([1, 2, 3])
print('Hello')
sum([1, 2, 3])
без собственного определения этих функций.
20. Глобальное имя определяется текущим состоянием модуля
Рассмотрим:
len = 5
def show_value():
print(len)
len = 7
show_value()
Результат:
7
Когда функция выполняется, Python ищет имя len в текущей глобальной области модуля.
На момент вызова:
show_value()
глобальное имя len уже связано со значением:
7
Поэтому будет использовано именно оно.
Python не ищет текст программы «вверх от места вызова» строка за строкой. Он обращается к текущему глобальному пространству имён.
Почему нельзя занимать встроенные имена
21. Затенение встроенной функции
Например:
len = 5
Теперь в этой глобальной области имя:
len
указывает на число, а не на встроенную функцию.
Если написать:
len([1, 2, 3])
возникнет ошибка, потому что Python сначала найдёт глобальное имя len.
До встроенной функции поиск уже не дойдёт.
Поэтому имена встроенных функций лучше не использовать для собственных переменных:
len
sum
max
min
str
int
list
tuple
...
dir() и области видимости
22. Что показывает dir() без аргументов
Вызов:
dir()
без аргументов возвращает список имён текущей области.
В глобальной области:
product_price = 1500
def calculate_price():
...
print(dir())
можно увидеть среди прочего:
calculate_price
product_price
Внутри функции:
def calculate_price(price):
discount = 100
print(dir())
можно увидеть:
['discount', 'price']
Таким образом, dir() удобно использовать на уроке, чтобы наглядно увидеть разницу между глобальными и локальными именами.
Константы и параметры функции
23. Константа в глобальной области
Предположим, программа рассчитывает площадь круга.
PI = 3.141592653589793
def calculate_circle_area(radius):
return PI * radius ** 2
Использование:
print(calculate_circle_area(5))
print(calculate_circle_area(10))
Здесь:
PI
— значение, которое одинаково для всех вычислений.
А:
radius
— входные данные конкретного вызова функции.
24. Почему radius является параметром
Радиус каждый раз может быть новым:
calculate_circle_area(5)
calculate_circle_area(10)
calculate_circle_area(25)
Поэтому функция получает его через параметр:
radius
Это часть входных данных функции.
Можно сформулировать вопрос:
Что должно меняться от одного вызова функции к другому?
В нашем случае:
radius
Поэтому его передаём аргументом.
25. Почему PI можно оставить константой
Значение PI не зависит от конкретного вызова:
радиус 5 → используется то же PI
радиус 10 → используется то же PI
радиус 25 → используется то же PI
Поэтому передавать его каждый раз:
calculate_circle_area(5, 3.141592653589793)
calculate_circle_area(10, 3.141592653589793)
не имеет смысла, если вся программа всегда должна использовать одну и ту же константу.
Глобальная константа записывается в верхнем регистре:
PI = 3.141592653589793
и функция может прочитать её из глобальной области.
Когда использовать параметр, а когда константу
26. Параметры — изменяемые входные данные
Например:
TAX_RATE = 0.18
def calculate_tax(price):
return price * TAX_RATE
Здесь:
price
является параметром, потому что стоимость меняется:
calculate_tax(1000)
calculate_tax(5000)
calculate_tax(12500)
А:
TAX_RATE
может быть константой, если для всей программы используется одна фиксированная ставка.
27. Если значение должно настраиваться — это уже хороший кандидат на параметр
Предположим, ставка зависит от конкретного расчёта:
def calculate_tax(price, tax_rate):
return price * tax_rate
Теперь можно писать:
calculate_tax(1000, 0.18)
calculate_tax(1000, 0.20)
Здесь ставка стала частью входных данных функции.
Практическое правило:
Если значение должно различаться между вызовами функции — обычно передаём его параметром.
Если значение является общей неизменяемой характеристикой программы или модуля — его можно оформить как константу.
28. Функции из встроенной области работают похожим образом
Мы не передаём функцию sum как отдельный аргумент:
def calculate_total(numbers):
return sum(numbers)
Параметр:
numbers
содержит изменяемые входные данные.
А имя:
sum
Python находит во встроенной области видимости.
Аналогично функция может обращаться к общей константе:
PI = 3.141592653589793
def calculate_circle_area(radius):
return PI * radius ** 2
Поиск PI:
Local → нет
Enclosing → нет
Global → найдено
Поиск radius:
Local → найдено
Важный принцип проектирования функций
29. Не превращаем все данные в глобальные
Технически можно написать:
RADIUS = 5
def calculate_circle_area():
return PI * RADIUS ** 2
Но тогда функция жёстко зависит от глобального RADIUS.
Для значения, которое является входом конкретного вычисления, лучше:
def calculate_circle_area(radius):
return PI * radius ** 2
Теперь функция может работать с любым радиусом:
calculate_circle_area(5)
calculate_circle_area(10)
calculate_circle_area(50)
Функция становится:
- универсальнее;
- понятнее;
- проще для повторного использования;
- проще для тестирования.
Основное по теме
Python ищет имена по правилу:
LEGB
Local
↓
Enclosing
↓
Global
↓
Built-in
Enclosing будет подробно изучаться позже.
Каждая функция создаёт собственную локальную область видимости.
def first_function():
first_value = 10
def second_function():
second_value = 20
Локальные имена одной функции не доступны напрямую другой функции.
Функция может читать глобальное имя:
value = 10
def show_value():
print(value)
Но если внутри функции существует присваивание тому же имени, Python рассматривает его как локальное:
value = 10
def show_value():
print(value)
value = 20
и обращение до присваивания приводит к:
UnboundLocalError
Локальное имя может скрывать глобальное:
value = 10
def show_value():
value = 20
print(value)
Глобальное имя может скрывать встроенное:
len = 10
поэтому встроенные имена занимать не следует.
dir() без аргументов помогает посмотреть имена текущей области видимости.
Для функций полезно разделять:
изменяемые входные данные → параметры
общие постоянные значения → константы
Например:
PI = 3.141592653589793
def calculate_circle_area(radius):
return PI * radius ** 2
Здесь:
radius → локальный параметр, меняется от вызова к вызову
PI → глобальная константа, одинакова для всей программы
Именно понимание областей видимости позволяет предсказывать, какое имя Python найдёт, какой объект за ним стоит и почему программа использует именно это значение.