Какие знаешь области видимости Python?

Области видимости в Python (LEGB)

Области видимости определяют, где и как переменные доступны в коде. Python использует правило LEGB для поиска переменных.

Правило LEGB

При поиске переменной Python проходит через четыре уровня видимости в таком порядке:

1. L — Local (локальная) — внутри функции
2. E — Enclosing (охватывающая) — в функции, которая содержит текущую функцию
3. G — Global (глобальная) — на уровне модуля
4. B — Built-in (встроенная) — встроенные функции Python (len, print, etc.)

# B - Built-in
print(len([1, 2, 3]))  # len — встроенная функция

# G - Global
global_var = "global"

def outer():
    # E - Enclosing
    enclosing_var = "enclosing"
    
    def inner():
        # L - Local
        local_var = "local"
        
        print(local_var)      # L - находит в локальной области
        print(enclosing_var)  # E - находит в охватывающей функции
        print(global_var)     # G - находит в глобальной области
        print(len)            # B - встроенная функция
    
    inner()

outer()

1. Local — локальная область видимости

Переменные, определённые внутри функции, видны только в этой функции:

def my_function():
    local_var = 10  # Локальная переменная
    return local_var

print(my_function())  # 10
# print(local_var)  # NameError: local_var не определена

2. Enclosing — охватывающая область

Распространяется в вложенные функции (функции внутри функций):

def outer_function():
    enclosing_var = 20  # Охватывающая переменная
    
    def inner_function():
        print(enclosing_var)  # Видна в вложенной функции
    
    inner_function()  # 20

outer_function()

3. Global — глобальная область

Переменные на уровне модуля, доступные везде в файле:

global_var = 100  # Глобальная переменная

def function1():
    print(global_var)  # 100 — видна

def function2():
    print(global_var)  # 100 — видна и здесь

function1()
function2()

Модификация глобальной переменной — используй ключевое слово global:

global_var = 100

def modify_global():
    global global_var  # Объявляем, что модифицируем глобальную переменную
    global_var = 200

print(global_var)  # 100
modify_global()
print(global_var)  # 200 — изменилась!

4. Built-in — встроенная область

Функции и константы, которые Python предоставляет автоматически:

print(len([1, 2, 3]))      # len — встроенная
print(sum([1, 2, 3]))      # sum — встроенная
print(type(42))            # type — встроенная
print(True)                # True, False, None — встроенные

Нюанс: Nonlocal

Для модификации переменной из охватывающей области используй nonlocal:

def outer():
    enclosing_var = 10
    
    def inner():
        nonlocal enclosing_var  # Модифицируем переменную из outer()
        enclosing_var = 20
    
    print(enclosing_var)  # 10
    inner()
    print(enclosing_var)  # 20 — изменилась!

outer()

Частая ошибка: Shadowing (затенение)

Переменная локальной области скрывает переменную из внешней области:

global_var = "global"

def function():
    global_var = "local"  # Создает локальную переменную, не изменяет глобальную
    print(global_var)  # "local"

function()
print(global_var)  # "global" — осталась нетронутой

Видимость в классах

Те же правила применяются в классах:

global_var = "global"

class MyClass:
    class_var = "class"  # Переменная класса
    
    def method(self):
        instance_var = "instance"  # Локальная переменная метода
        
        print(instance_var)  # instance
        print(self.class_var)  # class — через self
        print(global_var)    # global — глобальная видна

obj = MyClass()
obj.method()

Примеры скопов в замыканиях

Замыкания — отличный пример использования Enclosing области:

def make_multiplier(n):
    # n находится в Enclosing области
    def multiplier(x):
        return x * n  # Замыкание захватывает n
    return multiplier

multiply_by_3 = make_multiplier(3)
print(multiply_by_3(5))  # 15

multiply_by_10 = make_multiplier(10)
print(multiply_by_10(5))  # 50

Практические советы

1. Избегай глобальных переменных — код сложнее для тестирования и поддержки
2. Используй параметры функции — явнее и безопаснее
3. Замыкания удобны — для создания специализированных функций
4. Помни про LEGB — поиск идет снизу вверх по уровням
5. Используй global/nonlocal редко — признак того, что нужен рефакторинг

Выводы

Области видимости в Python следуют правилу LEGB:

• Local — внутри функции
• Enclosing — во вложенных функциях
• Global — на уровне модуля
• Built-in — встроенные функции Python

Понимание этих областей критично для написания чистого и предсказуемого кода.