Локальные и Глобальные Переменные Python: Область Видимости, Примеры

Что такое переменная в Python

Переменная представляет собой имя, которое ссылается на объект в памяти компьютера. В Python переменные не имеют фиксированных типов. Тип принадлежит объекту, на который ссылается переменная.

x = 42
x = "теперь строка"

Локальные переменные в Python

Определение локальных переменных

Локальная переменная определяется внутри функции и доступна только в пределах этой функции. После завершения работы функции локальная переменная удаляется из памяти.

def say_hello():
    name = "Python"  # локальная переменная
    print("Привет,", name)

say_hello()
# print(name)  # Ошибка: name не определена

Переменная name существует только в пределах функции say_hello и недоступна за её границами.

Преимущества локальных переменных

Локальные переменные обеспечивают изоляцию данных и предотвращают нежелательные изменения значений из других частей программы. Они автоматически освобождают память после завершения работы функции.

Глобальные переменные в Python

Что такое глобальные переменные

Глобальная переменная объявляется вне всех функций и доступна в любом месте программного файла. Такие переменные сохраняют свои значения на протяжении всего времени выполнения программы.

language = "Python"  # глобальная переменная

def show():
    print("Язык:", language)

show()  # Язык: Python

Проблемы с изменением глобальных переменных

При попытке изменить глобальную переменную внутри функции возникает ошибка:

counter = 0

def increment():
    counter += 1  # UnboundLocalError!

Python интерпретирует counter как локальную переменную из-за операции присваивания, но она не была определена локально.

Ключевое слово global

Использование global для изменения глобальных переменных

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

count = 0

def increment():
    global count
    count += 1

increment()
print(count)  # 1

Применение global в математических операциях

total = 0

def add(x):
    global total
    total += x

add(10)
add(20)
print(total)  # 30

Когда использовать global

Ключевое слово global следует применять осторожно, поскольку оно может усложнить отладку программы и сделать код менее читаемым.

Область видимости: правило LEGB

Принцип поиска переменных

Python ищет переменные по правилу LEGB в следующем порядке:

L (Local) — внутри текущей функции
E (Enclosing) — во вложенных функциях
G (Global) — на уровне модуля
B (Built-in) — встроенные имена Python

Пример работы правила LEGB

x = "global"

def outer():
    x = "enclosing"
    
    def inner():
        x = "local"
        print(x)
    
    inner()

outer()  # local

Python находит переменную x в локальной области и использует её значение.

Ключевое слово nonlocal

Доступ к переменным вложенных функций

Ключевое слово nonlocal используется для работы с переменными из внешней, но не глобальной области видимости:

def outer():
    count = 0
    
    def inner():
        nonlocal count
        count += 1
        return count
    
    return inner

f = outer()
print(f())  # 1
print(f())  # 2

Различия между global и nonlocal

Ключевое слово global работает с переменными модульного уровня, а nonlocal — с переменными из внешних функций в пределах одной области видимости.

Приватные переменные в Python

Соглашения об именовании

Python не поддерживает истинную приватность переменных, но использует соглашения:

_var — приватная переменная для внутреннего использования
__var — защищённая переменная с искажением имени
__var__ — магическая переменная системы

Пример приватных переменных в классах

class MyClass:
    def __init__(self):
        self.public = "доступно всем"
        self._private = "для внутреннего использования"
        self.__very_private = "с искажением имени"

obj = MyClass()
print(obj.public)        # доступно всем
print(obj._private)      # 123 (доступ есть, но не рекомендуется)
# print(obj.__very_private)  # AttributeError
print(obj._MyClass__very_private)  # работает через искажённое имя

Механизм искажения имён

Python автоматически изменяет имена переменных, начинающихся с двух подчёркиваний, добавляя к ним имя класса. Это усложняет случайный доступ к таким переменным.

Сравнение локальных и глобальных переменных

Основные различия

Локальные переменные действуют только внутри функции и автоматически удаляются после её завершения. Глобальные переменные доступны во всём модуле и сохраняются до завершения программы.

Производительность и безопасность

Локальные переменные обеспечивают лучшую производительность благодаря более быстрому доступу к памяти. Они также снижают риск побочных эффектов и конфликтов имён.

Правильное использование глобальных переменных

Подходящие случаи применения

Глобальные переменные уместны в следующих ситуациях:

Математические константы (PI = 3.14159)
Настройки конфигурации приложения
Флаги отладки (DEBUG = True)
Кэширование данных при отсутствии альтернатив

Случаи, когда следует избегать

Не используйте глобальные переменные для:

Передачи данных между функциями
Хранения изменяемого состояния
Временных вычислений
Счётчиков и аккумуляторов

Практические примеры и решения

Счётчик вызовов функции

Неправильный подход с глобальной переменной:

count = 0

def handler():
    global count
    count += 1

Правильное решение с замыканием:

def create_counter():
    count = 0
    
    def counter():
        nonlocal count
        count += 1
        return count
    
    return counter

my_counter = create_counter()
print(my_counter())  # 1
print(my_counter())  # 2

Конфигурация приложения

Правильное использование глобальных констант:

DATABASE_URL = "postgresql://localhost:5432/mydb"
MAX_CONNECTIONS = 100
TIMEOUT_SECONDS = 30

def connect_to_database():
    # использование глобальных констант
    connection = create_connection(DATABASE_URL, TIMEOUT_SECONDS)
    return connection

Отладка проблем с областью видимости

Частые ошибки

UnboundLocalError возникает при попытке изменить переменную, которую Python считает локальной, но она не была определена в функции.

Способы диагностики

Используйте встроенные функции locals() и globals() для просмотра доступных переменных:

x = "глобальная"

def test():
    y = "локальная"
    print("Локальные:", locals())
    print("Глобальные:", list(globals().keys()))

test()

Лучшие практики работы с переменными

Основные рекомендации

Используйте локальные переменные по умолчанию
Объявляйте глобальные константы заглавными буквами
Применяйте соглашения об именовании для приватности
Избегайте изменения глобального состояния из функций
Предпочитайте передачу параметров глобальным переменным

Принципы чистого кода

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

Часто задаваемые вопросы

Как правильно объявить глобальную переменную

Объявите переменную вне всех функций на уровне модуля. Для изменения внутри функции используйте ключевое слово global.

В чём разница между global и nonlocal

Ключевое слово global работает с переменными уровня модуля, а nonlocal — с переменными из внешних функций во вложенных конструкциях.

Существуют ли настоящие приватные переменные

Python не имеет истинного механизма приватности. Приватность реализуется через соглашения об именовании и социальный договор между разработчиками.

Когда оправдано использование глобальных переменных

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

Заключение

Понимание области видимости переменных критически важно для написания качественного Python-кода. Локальные переменные обеспечивают безопасность и изоляцию данных, в то время как глобальные переменные требуют осторожного применения.

Основные принципы работы с переменными включают предпочтение локальных переменных, осознанное использование глобальных констант и соблюдение соглашений о приватности. Правильное понимание правила LEGB и ключевых слов global и nonlocal поможет избежать распространённых ошибок и создавать более надёжные программы.