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

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

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

В Python переменная, объявленная вне функции или в глобальной области видимости, называется глобальной переменной. К глобальной переменной можно получить доступ как внутри, так и вне функции.

Давайте посмотрим на примере, как в Python создается глобальная переменная.

Пример 1. Создаем глобальную переменную

x = "глобальная переменная"
def foo():
    print("x внутри функции:", x)

foo()
print("x вне функции:", x)

Вывод: 

x внутри функции: глобальная переменная
x вне функции: глобальная переменная

В приведенной выше программе мы создали глобальную переменную x и задали функцию foo(), которая выводит на экран значение x. В коде программы мы вызвали функцию foo(), которая напечатала значение x внутри функции. Как вы видите, оно совпадает со значением x вне функции.

А что если нужно изменить значение x внутри функции?

x = "глобальная переменная"

def foo():
    x = x * 2
    print(x)

foo()

Вывод:

UnboundLocalError: local variable 'x' referenced before assignment

Python выдает ошибку, потому что он обрабатывает x как локальную переменную, но x при этом не определена внутри функции foo().

Чтобы исправить эту ошибку, нам понадобится ключевое слово global. О том, что это такое и как оно работает, подробнее можете почитать в статье «Ключевое слово global».

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

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

Пример 2. Доступ к локальной переменной вне области видимости

def foo():
    y = "локальная переменная"

foo()
print(y)

Вывод:

NameError: name 'y' is not defined

Python выдает ошибку, потому что мы пытаемся получить доступ к локальной переменной y в глобальной области видимости. Так делать нельзя: локальная переменная y «существует» только внутри функции foo().

Давайте рассмотрим пример, который демонстрирует, как в Python создаются локальные переменные. 

Пример 3. Создаем локальную переменную

Мы создаем локальные переменные, когда, например, объявляем переменные внутри функции. 

def foo():
    y = "локальная переменная"
    print(y)

foo()

Вывод:

локальная переменная

Теперь вернитесь к программе, в которой x была глобальной переменной, а нам нужно было изменить эту переменную внутри функции foo().

Глобальные и локальные переменные

В этом разделе мы поговорим о том, как использовать глобальные и локальные переменные в одной программе.

Пример 4. Локальные и глобальные переменные в одной программе

x = "глобальная переменная"

def foo():
    global x
    y = "локальная переменная"
    x = x * 2
    print(x)
    print(y)

foo()

Вывод:

глобальная переменная глобальная переменная
локальная переменная

В приведенном выше программе мы объявили глобальную переменную x и локальную переменную y внутри функции foo(). Затем мы использовали оператор умножения, чтобы изменить глобальную переменную x, и вывели на экран значения переменных x и y. 

После вызова функции foo() значение x становится равным "глобальная переменная глобальная переменная", потому что внутри функции строка "глобальная переменная" умножается на два. Затем функция foo() выводит на экран новое значение x и значение переменной y — "локальная переменная".

Пример 5. Глобальная и локальная переменные с одинаковым именем

x = 5

def foo():
    x = 10
    print("локальная переменная x:", x)

foo()
print("глобальная переменная x:", x)

Вывод:

локальная переменная x: 10
глобальная переменная x: 5

В приведенной выше программе мы использовали одно и то же имя x как для глобальной переменной, так и для локальной переменной. Python выводит разные значения переменных x, потому что локальная переменная объявлена внутри функции `foo()`, а другая — вне ее, то есть в глобальной области видимости. 

Когда мы печатаем переменную x внутри функции foo(), на экран выводится сообщение "локальная переменная x: 10". Это называется локальной областью видимости переменной.

Когда мы печатаем переменную x за пределами foo(), на экран выводится сообщение "глобальная переменная x: 5". Это называется глобальной областью видимости переменной.

Нелокальные переменные

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

Давайте на примере рассмотрим, как нелокальная переменная работает в Python.

Для этого нам понадобится ключевое слово nonlocal.

Пример 6. Создаем нелокальную переменную

def outer():
    x = "локальная переменная"

    def inner():
        nonlocal x
        x = "нелокальная переменная x"
        print("вложенная функция:", x)

    inner()
    print(":", x)

outer()

Вывод:

вложенная функция: нелокальная переменная
внешняя функция: нелокальная переменная

В приведенной выше программе есть вложенная функция inner(). Для создания нелокальной переменной мы используем ключевое слово nonlocal. Функция inner() определяется внутри функции outer().

Примечание. Если мы изменим значение нелокальной переменной, изменится и значение локальной переменной.