Область видимости в Python
Вы, наверное, не раз слышали термин область видимости, когда изучали программирование. Это весьма важная тема, незнание которой может привести к достаточно запутанным ошибкам. Область видимости указывает интерпретатору, когда наименование (или переменная) видимо. Другими словами, область видимости определяет, когда и где вы можете использовать свои переменные, функции, и т.д. Если вы попытаетесь использовать что-либо, что не является в вашей области видимости, вы получите ошибку NameError.
Python содержит три разных типа области видимости:
Локальная область видимости
Локальная область видимости наиболее часто используется в Python. Когда мы создаем переменную в блоке кода, она будет разрешена при помощи ближайшей области видимости, или областей. Группирование всех этих областей известно как среда блоков кода. Другими словами, все назначения выполняются в локальной области по умолчанию. Если вам нужно что-то другое, тогда вам нужно настроить свою переменную на глобальную или нелокальную область, которые мы рассмотрим немного позже. Сейчас мы создадим простой пример, используя интерпретатор Python, в котором демонстрируется назначение локальной области видимости.
Все, что вы хотели узнать про области видимости в Python, но стеснялись спросить
В преддверии старта нового потока по курсу «Разработчик Python», решили поговорить про области видимости в Python. Что из этого вышло? — Читайте в материале ниже.
Сегодня мы будем говорить о важных теоретических основах, которые необходимо понимать и помнить, чтобы писать грамотный, читаемый и красивый код. Мы будем вести речь об областях видимости переменных. Эта статья будет полезна не только новичкам, но и опытным программистам, которые пришли в Python из другого языка и хотят разобраться с его механиками работы.
Области видимости определяют, в какой части программы мы можем работать с той или иной переменной, а от каких переменная «скрыта». Крайне важно понимать, как использовать только те значения и переменные, которые нам нужны, и как интерпретатор языка себя при этом ведет. А еще мы посмотрим, как обходить ограничения, накладываемые областями видимости на действия с переменными. В Python существует целых 3 области видимости:
Обычно, речь заходит про области видимости, когда происходит знакомство с функциями. На их примере мы и будем рассматривать работу областей видимости переменных.
Локальная область видимости
Рассмотрим функцию, которая выведет список some_list поэлементно:
Теперь мы поступим следующим образом:
Здесь переменная element внутри функции и переменная с таким же именем вне ее – это две разные переменные, их значения не перекрещиваются и не взаимозаменяются. Они называются одинаково, но ссылаются на разные объекты в памяти. Более того, переменная с именем element внутри функции живет столько же, сколько выполняется функция и не больше. Но будьте аккуратны с тем, чтобы давать локальным и глобальным переменным одинаковые имена, сейчас покажу почему:
Обратите внимание на то, что интерпретатор не указал нам на ошибки. А все потому что sudden_list находится в глобальной области видимости, то есть изнутри функции print_list мы можем к нему обращаться, поскольку изнутри видно то, что происходит снаружи. По причине таких механик работы старайтесь называть локальные переменные внутри функции не так, как называете переменные в глобальной области видимости.
Здесь важно поговорить о константах. Интерпретатору Python нет разницы как вы называете переменную, поэтому код выше будет лучше переписать в следующем виде:
Теперь все на своих местах. Дело в том, что в Python нельзя каким-то образом строго определить константу, как объект, который не должен быть изменен. Так что то, как вы используете значение переменной, имя которой записано заглавными буквами, остается лишь на вашей совести. Другой вопрос, что таким способом записанная переменная даст понять тому, кто будет читать ваш код, что переменная нигде изменяться не будет. Или по крайней мере не должна.
Глобальная область видимости
В результате получим:
Однако менять значение глобальной переменной изнутри функции – не лучшая практика и лучше так не делать, поскольку читаемости кода это не способствует. Чем меньше то, что происходит внутри функции будет зависеть от глобальной области видимости, тем лучше.
Нелокальная область видимости
Насколько это полезно вам предстоит решить самостоятельно. Больше примеров вы можете найти здесь.
В качестве вывода можно сформулировать несколько правил:
Как создать и объявить глобальную переменную в Python
Переменная, к которой может получить доступ другой блок, называется глобальной переменной. Его можно определить вне блока. Другими словами, глобальная переменная определяется вне функции, и мы можем получить к ней доступ внутри функции.
С другой стороны, переменная, определенная в блоке и доступная для этого блока, называется локальной переменной. К такой переменной можно получить доступ только в определенном блоке.
Давайте разберемся как создать и объявить глобальную переменную в Python и посмотрим примеры локальной и глобальной переменных.
Пример локальной переменной:
Переменная определяется внутри функции и может использоваться только в определенной функции, поэтому природа переменной называется локальной переменной. Мы не можем получить к ним доступ в других функциях.
Чтобы преодолеть эту проблему, мы используем глобальные переменные. Давайте разберемся в примере глобальной переменной.
В приведенном выше коде мы определили две глобальные переменные a и b вне функций. Мы использовали их внутри функций sum() и sub(). Обе функции вернули результат при вызове.
Если мы определим локальную переменную с таким же именем, она напечатает значение, которое находится внутри функции, а затем значение глобальной переменной.
Мы определили локальную переменную с тем же именем, что и глобальная переменная; сначала напечатали локальную переменную, а затем значение глобальной переменной.
Глобальное ключевое слово
Python предоставляет глобальное ключевое слово, которое используется для изменения значения глобальной переменной внутри функции. Это полезно, когда мы хотим изменить значение глобальной переменной или присвоить другое значение. Ниже приведены несколько правил для определения глобальных переменных.
Правила глобальных ключевых слов:
Пример – без глобального ключевого слова:
В приведенном выше коде возникла ошибка, поскольку мы пытались присвоить значение глобальной переменной. Мы можем изменить значение глобального значения внутри функции, используя ключевое слово global.
Пример – с глобальным ключевым словом:
В приведенном выше примере мы определили переменную c в функции mul() с помощью ключевого слова global. Значение c умножается на 10; следовательно, возвращается 200. Мы видим в выходных данных, что изменение значения внутри функции отражается на значении вне глобальной переменной.
Глобальные переменные в модулях Python
Преимущество ключевого слова global заключается в создании глобальных переменных и совместном использовании их между различными модулями. Например, мы создаем name.py, который состоит из глобальных переменных. Если мы изменим эти переменные, то это изменение отразится повсюду. Давайте разберемся в следующем примере.
Код – 1: Создайте файл name.py для хранения глобальных переменных.
Код – 2: Создайте файл change.py для изменения глобальных переменных.
Здесь мы изменили значение a, b и msg. Эти глобальные переменные были определены в файле name.py, и мы импортировали name и получили доступ к этим переменным.
Код – 3: Создайте файл result.py для печати измененных глобальных переменных.
Ключевое слово global во вложенных функциях
Мы можем использовать ключевое слово global внутри вложенной функции. Мы должны объявить переменную, используя ключевое слово global внутри вложенной функции. Давайте разберемся в следующем примере.
В приведенном выше коде значение внутри add() принимает значение локальной переменной x = 15. В функции modify() мы присвоили x = 20 с помощью ключевого слова global. Это изменение отражено в переменной функции add().
Ключевое слово global
В этой статье вы узнаете, для чего нужно ключевое слово global и когда его использовать. А еще мы подробнее поговорим о глобальных переменных.
Поэтому перед прочтением этой статьи ознакомьтесь со статьей «Глобальные, локальные и нелокальные переменные в Python».
Что это такое
Ключевое слово global позволяет изменять переменную вне текущей области видимости в Python. global используется для создания глобальной переменной и изменения ее в локальной области видимости.
Что нужно знать прежде, чем работать с global
Как использовать global
Пример 1. Получаем доступ к глобальной переменной внутри функции
Вывод:
Все работает! Но что если нам нужно изменить глобальную переменную внутри функции?
Пример 2. Изменяем глобальную переменную внутри функции
Вывод:
Python сообщает нам, что мы использовали локальную переменную c до ее объявления. Дело в том, что получить доступ к глобальной переменной внутри функции мы можем, а вот изменять ее в локальной области видимости — уже нет.
Пример 3. Изменяем глобальную переменную внутри функции с помощью global
Вывод:
В приведенной выше программе мы определяем c как глобальную переменную внутри функции add() с помощью ключевого слова `global`.
Глобальные переменные в модулях Python
В Python принято создавать единый модуль config.py для хранения глобальных переменных и обмена информацией между модулями Python в одной программе.
Вот как можно использовать глобальные переменные между модулями Python.
Пример 4. Используем глобальную переменную между модулями
Вывод:
Как использовать global во вложенных функция
Пример 5. Используем глобальные переменные во вложенных функциях
Вывод:
Область видимости
Область видимости переменных в языке программирования Python представляет собой некое пространство имен, в рамках которого функционируют созданные объекты. Эта особенность позволяет ограничивать доступ к определенным значениям во избежание конфликтов между одинаковыми идентификаторами. Переменные бывают двух видов: локальные и глобальные, что в большинстве случае определяется местом их первичной идентификации в программе.
Локальные переменные
Для создания переменных, обладающих локальной областью видимости, необходимо всего лишь поместить их в отдельный блок кода, изолированный от остальной программы. Чтобы увидеть локальную переменную в действии, достаточно инициализировать целочисленный объект с именем x и значением 100 в функции f, как это сделано в следующем примере:
Здесь x имеет локальную область видимости, так как доступна лишь в рамках своей функции f. Вызывая данную функцию из внешней части программы, можно увидеть вывод целочисленного значения на экране. Однако, если попытаться вывести переменную x при помощи метода print вне зоны действия функции f, компилятор тут же выдаст ошибку:
Так происходит из-за того, что внешняя часть программы ничего не знает о переменной x, поскольку содержит в себе совсем другое пространство имен. Пользоваться локальными объектами можно только в той области, где они были идентифицированы. В обратном же случае компилятор сообщит об ошибке, не сумев обнаружить необходимую переменную.
Глобальные переменные
Чтобы иметь возможность использовать некоторое значение в любой части программы, следует объявить глобальную переменную. Для этого понадобиться создать переменную отдельно от области кода, ограниченной определенным блоком кода, например, функцией. В следующем примере демонстрируется идентификация целочисленного типа данных под названием x, который позже выводится на экран при помощи метода print в функции f:
Как можно заметить из результатов выполнения программы, значение 100 воспроизводится не только через f, но и с помощью обычного print. Таким образом, получение доступа к x осуществляется из любой части кода, благодаря глобальной области видимости подобного объекта. Но что будет, если попытаться изменить значение глобальной переменной в некой функции? Результаты такого эксперимента представлены в следующем фрагменте кода:
Функция f присваивает значение 200 переменной с именем x, однако, вопреки ожиданиям, внешний метод print выводит число 100, которое принадлежало x изначально. Происходит так потому, что в данной программе создаются два разных объекта x с локальной, а также глобальной областью видимости. Исправить ситуацию поможет ключевое слово global:
Пометив переменную x как global, можно обращаться к ее изначальному значению, которое было определено вне зоны действия функции f. Теперь после того как в x поместили число 200, вызов метода print выводит вполне ожидаемый результат, то есть измененное значение.
Но все таки не стоит злоупотреблять. Зачастую гораздо правильнее передавать в функции необходимые значения в качестве аргуменов, а если нужно перезаписать какое-то глобальное значение, то возвращать его из функции.
Нелокальные переменные
Итак, для обращения к глобальной переменной внутри функции f необходимо использовать ключевое слово global перед ее идентификатором. Но что если требуется вызывать совсем не глобальную, а переменную, которая была определена во внешнем методе, являясь при этом локальной для другого пространства имен, находящегося на уровень выше? Следующий код демонстрирует попытку взаимодействия со значением из внешней функции f1 в методе f2:
Несмотря на то, что переменной с таким же именем x было присвоено новое значение 200, в результате выполнения написанных методов на экране отобразилось 100. Как и в том случае с двумя разными переменными, локальной и глобальной, здесь имеется также два различных объекта, которые идентифицированы в отдельных блоках кода. Чтобы обратиться к объекту, который не является локальным, необходимо воспользоваться модификатором nonlocal:
Таким образом, в методе f2 осуществляется запись значения 200 в переменную x из функции f1. В результате подобных действий, вызов метода f1 из внешней части программы создает новую переменную x, значение которой меняется в f2 со 100 на 200 и выводится при помощи print.
Видимость из загружаемого модуля
Теперь разберемся с видимостью глобальных переменных между загружаемыми модулями Python. Например, мы подключаем другой модуль с помощью команды import. Создадим файл «test.py» и в него запишем следующий код:
То есть мы определили глобальную переменную x для модуля test. Так же определили функцию, которая выводит на экран её значение.
Теперь создадим файл main.py, который и будем запускать. В нем мы импортируем модуль test, а так же создадим свою глобальную переменную x. После этого выведем значения глобальной переменной из test, вызовим функцию f, а так же проверим, что значение переменной в модуле main не изменилось:
Мы в первой же строчке записали в x значение 200. Это было сделано, чтобы показать, что после того, как мы загрузим внешний модуль, значение этой переменной не изменится. Так и вышло. Обращаясь к переменной из загруженной библиотеки, удалось прочитать его и изменить значение.
Теперь модифицируем программу следующим образом:
В этом случае для загрузки мы использовали команду «from test import *». Мы импортировали все переменные и функции. После загрузки модуля значение переменной x в модуле main изменилось. Но при вызове функции, мы получаем значение x из модуля test. После присвоения нового значения переменной x, значение, которое выводит функция f не изменяется.
Глобальные переменные в классе
Точно так же как и в функциях, можно обращаться к глобальным переменным и в классе Python. Разберем пример:
Мы объявили глобальную переменную x. Вывели значение переменной до и после объявления класса. Как видим значение изменилось. После того как мы создали объект класса, значение в очередной раз поменялось. Это произошло, потому что сработал конструктор класса — метод __init__. После вызова функции f у созданного объекта, значение стало 400. В Python использование global переменная и в функции класса, и в его конструкторе, и после описания класса дают возможность изменения глобальной переменной. Если убрать это объявление, то тогда выполнится присвоение локальной переменной.
Конечно же если мы определим локальную переменную в классе, то к ней не будет возможности доступа из другого класса:
Для того, чтобы код работал, переменная x должна быль глобальной.
Заключение
Таким образом, область видимости переменных в языке программирования Python, является важной составляющей платформы. Правильное взаимодействие со всеми ее особенностями позволяет избежать множества довольно сложных ошибок. Для более безопасного контроля над видимостью отдельных объектов применяются ключевые слова global и nonlocal. Чтобы ознакомиться с дополнительными сведениями по данной теме, следует изучить PEP 3104.
