built_in_var = len  # B - Built-in: функция len()

global_var = "Я глобальная переменная"  # G - Global

def outer_function():
    enclosing_var = "Я объемлющая переменная"  # E - Enclosing
    
    def inner_function():
        local_var = "Я локальная переменная"  # L - Local
        print(local_var)
        print(enclosing_var)
        print(global_var)
        print(built_in_var([1, 2, 3]))
        
    inner_function()

outer_function()

x = 100

def check_namespaces():
    y = 200
    # locals() возвращает {'y': 200}
    print("Локальные:", locals())
    # globals() вернет большой словарь, где будет {'x': 100, ...}
    print("Есть ли 'x' в глобальных?", 'x' in globals())

check_namespaces()

user_id = 101  # Глобальная переменная

def process_user(user_id):
    # Здесь user_id - это локальная переменная (параметр функции)
    # Она затеняет глобальную переменную user_id
    user_id = user_id + 50
    print("Внутри функции user_id =", user_id)

process_user(500)
print("Снаружи функции user_id =", user_id)

counter = 0  # Глобальная переменная

def bad_increment():
    # Эта строка вызовет UnboundLocalError
    # counter = counter + 1
    pass

# Правильный подход (Функциональный стиль):
def good_increment(current_value):
    return current_value + 1

counter = good_increment(counter)
print(counter)  # Выведет: 1

my_list = [1, 2, 3]  # Глобальный изменяемый объект

def mutate_list():
    # Это сработает без ошибок! Мы не переприсваиваем переменную,
    # мы вызываем метод существующего объекта.
    my_list.append(4)
    
mutate_list()
print(my_list)  # Выведет: [1, 2, 3, 4]

logged_in = False  # Глобальный флаг состояния

def login_user():
    global logged_in  # Явное указание использовать глобальную переменную
    # Без строки выше, это присваивание создало бы локальную переменную
    logged_in = True
    print("Пользователь вошел в систему.")

def check_status():
    # Для ЧТЕНИЯ global не нужен, LEGB найдет переменную
    if logged_in:
        print("Доступ разрешен.")
    else:
        print("Доступ запрещен.")

check_status() # Доступ запрещен
login_user()
check_status() # Доступ разрешен

settings = {"theme": "dark", "language": "en"}

def update_settings():
    # Мы не переприсваиваем переменную 'settings',
    # мы изменяем ключ внутри словаря. 
    # Ключевое слово global ЗДЕСЬ НЕ НУЖНО!
    settings["theme"] = "light"
    
    # А вот если бы мы захотели заменить ВЕСЬ словарь новым,
    # тогда global был бы обязателен:
    # global settings
    # settings = {"theme": "light", "language": "ru"}

update_settings()
print(settings)  # Выведет: {'theme': 'light', 'language': 'en'}

def make_multiplier(factor): # Внешняя функция (Enclosing scope)
    # factor живет в объемлющей области для функции inner
    def inner(number):       # Внутренняя функция (Local scope)
        # inner 'видит' и запоминает переменную factor
        return number * factor
    return inner  # Возвращаем саму функцию (создаем замыкание)

# Создаем функцию, которая умножает на 5
times_five = make_multiplier(5)

# Внешняя функция уже завершилась, но times_five помнит factor=5
print(times_five(10))  # Выведет: 50
print(times_five(2))   # Выведет: 10

def create_counter():
    count = 0  # Переменная в объемлющей области
    
    def counter():
        nonlocal count  # Разрешаем изменять переменную из внешней функции
        count += 1
        return count
        
    return counter

# Создаем два независимых счетчика
counter_a = create_counter()
counter_b = create_counter()

print("Counter A:", counter_a(), counter_a())  # Выведет: Counter A: 1 2
print("Counter B:", counter_b())               # Выведет: Counter B: 1
print("Counter A:", counter_a())               # Выведет: Counter A: 3

# ОШИБОЧНЫЙ ПАТТЕРН (Затенение built-in):
def calculate_stats(numbers):
    # Создаем локальные переменные, затеняющие встроенные функции!
    min = 0 
    max = 100
    sum = 0
    
    for n in numbers:
        sum += n
        
    # ОШИБКА: попытка вызвать встроенную функцию max(), 
    # но имя 'max' теперь ссылается на число 100!
    # return max(numbers)

# ПРАВИЛЬНЫЙ ПАТТЕРН:
def calculate_stats_correct(numbers):
    min_val = 0   # Изменяем имя переменной
    max_val = 100
    total_sum = 0 # Используем синонимы
    
    # Теперь встроенные функции min, max и sum работают корректно!
    return sum(numbers) / len(numbers)

# ПРОБЛЕМА ПОЗДНЕГО СВЯЗЫВАНИЯ (Late Binding)
multipliers_bad = []
for i in range(3):
    # Замыкание ссылается на переменную i, которая меняется
    multipliers_bad.append(lambda x: x * i)

# Все три функции умножают на 2, так как i после цикла равно 2
print([m(10) for m in multipliers_bad])  # Выведет: [20, 20, 20]

# РЕШЕНИЕ: Использование аргумента по умолчанию (Early Binding)
multipliers_good = []
for i in range(3):
    # i=i замораживает текущее значение на этапе определения функции
    multipliers_good.append(lambda x, i=i: x * i)

print([m(10) for m in multipliers_good]) # Выведет: [0, 10, 20]

import math
import time

def slow_function():
    # На каждой итерации Python ищет модуль math и функцию sqrt в Global
    result = []
    for i in range(10_000_000):
        result.append(math.sqrt(i))

def fast_function():
    # Мы создаем локальные ссылки! Поиск L -> мгновенно.
    local_append = result.append
    local_sqrt = math.sqrt
    result = []
    for i in range(10_000_000):
        local_append(local_sqrt(i))

# fast_function() выполнится заметно быстрее, так как пропускает 
# этапы E, G и поиск атрибутов объекта в цикле.