какая переменная в коде локальная а какая глобальная
Область видимости
Область видимости переменных в языке программирования 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.
Область видимости переменных в C++: локальные и глобальные переменные
Всем привет! Сегодня мы затронем тему, которую должны были изучить еще в самом начале пути изучения C++ — область видимости переменных. Мы разберем, что такое локальные и глобальные переменные.
Область видимости переменных в C++
Область видимости переменных — это те части программы, в которой пользователь может изменять или использовать переменные в своих нуждах.
В C++ существуют отдельные блоки, которые начинаются с открывающей скобки ( < ) и заканчиваются соответственно закрывающей скобкой ( >). Такими блоками являются циклы (for, while, do while) и функции.
Если переменная была создана в таком блоке, то ее областью видимости будет являться этот блок от его начала (от открывающей скобки — < ) и до его конца (до закрывающей скобки — >) включая все дочерние блоки созданные в этом блоке.
В примере ниже, программист ошибся с областью видимости:
А вот ошибки в строке 6 нет, поскольку второй цикл находится в первом цикле (является дочерним блоком первого цикла) и поэтому переменная b может спокойно там использоваться.
Глобальные переменные в C++
Глобальными переменными называются те переменные, которые были созданы вне тела какого-то блока. Их можно всегда использовать во всей вашей программе, вплоть до ее окончания работы. В примере ниже мы создали две глобальные переменные global и global_too и использовали их в функции summa :
Вот, что выведет данная программа:
Как видите глобальные переменные видны везде. В нашем примере внутри функции summa мы не создавали ни какие переменные, мы лишь использовали две глобальные переменные, которые были созданы раньше.
Локальные переменные
Локальные переменные — это переменные созданные в блоках. Областью видимости таких переменных является блоки ( и все их дочерние ), а также их область видимости не распространяется на другие блоки. Как ни как, но эти переменные созданы в отдельных блоках.
Из этого можно сделать вывод: у нас есть возможность создавать переменные с одинаковыми именами, но в разных блоках (или другими словами, чтобы их область видимости не совпадала друг с другом).
Нужно запомнить! Если вы создали локальную переменную, то вы должны понимать, что использование ее в других блоках будет невозможным.
Глобальная переменная уступает локальной
Если мы создадим глобальную переменную и с таким же именем локальную, то получится, что там где была создана локальная переменная будет использоваться именно локальная переменная, а не глобальная. Так как локальная переменная считается по приоритету выше глобальной. Давайте разберем, как это работает на примере ниже:
А вот, если мы вызовем функцию sait_message то результатом будет:
Вот так глобальная переменная уступает локальной!
Мы советуем вам не создавать переменные с одинаковыми именами, поскольку в будущем вам будет тяжело разобраться в коде, если там будут присутствовать одинаковые переменные.
Глобальный оператор разрешения
В случае создания двух переменных с одинаковым именем (одна из которых является глобальной, а другая локальной) при использовании в блоке, в котором была объявлена локальная переменная, можно использовать и глобальную переменную. Для ее использования нужно всего лишь применить глобальный оператор разрешения.
Глобальный оператор разрешения — это два подряд поставленные двоеточия, с помощью которых мы говорим компилятору, что хотим использовать глобальную переменную, а не локальную.
Чтобы использовать глобальный оператор разрешения нужно применять данную конструкцию:
Глобальные, локальные и нелокальные переменные
В этом руководстве вы узнаете о глобальных, локальных и нелокальных переменных в Python и о том, где и как их использовать.
Глобальные переменные
В Python переменная, объявленная вне функции или в глобальной области видимости, называется глобальной переменной. К глобальной переменной можно получить доступ как внутри, так и вне функции.
Давайте посмотрим на примере, как в Python создается глобальная переменная.
Пример 1. Создаем глобальную переменную
Вывод:
А что если нужно изменить значение x внутри функции?
Вывод:
Локальные переменные
Переменная, объявленная внутри тела функции или в локальной области видимости, называется локальной переменной.
Пример 2. Доступ к локальной переменной вне области видимости
Вывод:
Давайте рассмотрим пример, который демонстрирует, как в Python создаются локальные переменные.
Пример 3. Создаем локальную переменную
Мы создаем локальные переменные, когда, например, объявляем переменные внутри функции.
Вывод:
Глобальные и локальные переменные
В этом разделе мы поговорим о том, как использовать глобальные и локальные переменные в одной программе.
Пример 4. Локальные и глобальные переменные в одной программе
Вывод:
Пример 5. Глобальная и локальная переменные с одинаковым именем
Вывод:
Нелокальные переменные
Нелокальные переменные используются во вложенных функциях, локальная область видимости которых не определена. Это означает, что переменная может не находиться ни в локальной, ни в глобальной области.
Давайте на примере рассмотрим, как нелокальная переменная работает в Python.
Пример 6. Создаем нелокальную переменную
Вывод:
Примечание. Если мы изменим значение нелокальной переменной, изменится и значение локальной переменной.
Переменные Python – руководство по применению
В Python нам не нужно указывать тип переменной, потому что Python – это язык вывода и достаточно умен, чтобы получить тип переменной.
Имена переменных могут состоять из букв и цифр, но они должны начинаться с буквы или символа подчеркивания. Для имени рекомендуется использовать строчные буквы. Rahul и rahul – две разные переменные.
Что такое переменная в Python?
Переменная в Python – это имя, которое используется для обозначения ячейки памяти. Переменные также известны как идентификаторы и используются для хранения значений.
Наименование идентификатора
Переменные – это пример идентификаторов. Идентификатор используется для распознавания литералов в программе. Правила присвоения имени идентификатору приведены ниже.
Объявление переменной и присвоение значений
Python не обязывает нас объявлять переменную перед ее использованием в приложении. Это позволяет нам создавать переменную в нужное время.
Нам не нужно явно объявлять переменную в Python. Когда мы присваиваем переменной какое-либо значение, эта переменная объявляется автоматически. Оператор равенства(=) используется для присвоения значения переменной.
Ссылки на объекты
Когда мы объявляем переменную, необходимо понимать, как работает интерпретатор Python. Процесс обработки переменных несколько отличается от многих других языков программирования.
Python – это объектно-ориентированный язык программирования; каждый элемент данных принадлежит к определенному типу класса. Рассмотрим следующий пример.
Объект Python создает целочисленный объект и отображает его на консоли. В приведенном выше операторе печати мы создали строковый объект. Давайте проверим его тип с помощью встроенной функции Python type().
В Python переменные – это символическое имя, которое является ссылкой или указателем на объект. Переменные используются для обозначения объектов этим именем.
Давайте разберемся в следующем примере:
На изображении выше переменная a относится к целочисленному объекту.
Предположим, мы присвоили целочисленное значение 50 новой переменной b.
Переменная b относится к тому же объекту, на который указывает a, поскольку Python не создает другой объект.
Присваиваем новое значение b. Теперь обе переменные будут ссылаться на разные объекты.
Python эффективно управляет памятью, если мы присвоим одной и той же переменной два разных значения.
Идентичность объекта
В Python каждый созданный объект уникально идентифицируется в Python. Python гарантирует, что два объекта не будут иметь одинаковый идентификатор. Встроенная функция id() используется для распознавания идентификатора объекта. Рассмотрим следующий пример.
Мы присвоили b = a, a и b обе точки на один и тот же объект. Когда мы проверили их с помощью функции id(), она вернула то же число. При a = 500 функция ссылается на новый идентификатор объекта.
Имена переменных
Мы уже обсуждали, как объявить допустимую переменную. Имена переменных могут быть любой длины, могут иметь заглавные и строчные буквы(от A до Z, от a до z), цифру(0-9) и символ подчеркивания(_). Рассмотрим следующий пример правильных имен переменных.
Рассмотрим следующее допустимое имя переменных.
В приведенном выше примере мы объявили несколько допустимых имен переменных, таких как name, _name_ и т. д. Но такие имена не рекомендуется присваивать, потому что, когда мы пытаемся прочитать код, это может создать путаницу. Имя переменной должно быть описательным, чтобы код был более читабельным.
Ключевые слова из нескольких слов могут быть созданы следующим способом.
Множественное присвоение
Python позволяет нам присваивать значение нескольким переменным в одном операторе, что также известно как множественное присваивание.
Мы можем применить несколько присваиваний двумя способами: либо назначив одно значение нескольким переменным, либо назначив несколько значений нескольким переменным. Рассмотрим следующий пример.
1. Присвоение одного значения нескольким переменным:
2. Присвоение нескольких значений нескольким переменным:
Значения будут присвоены в порядке появления переменных.
Типы переменных Python
В Python есть два типа переменных – локальная переменная и глобальная переменная. Давайте в них разберемся.
Локальная переменная
Локальные переменные – это переменные, которые объявлены внутри функции и имеют область видимости внутри функции.
В приведенном выше коде мы объявили функцию с именем add() и присвоили ей несколько переменных. Эти переменные будут называться локальными переменными, которые имеют область видимости только внутри функции. Если мы попытаемся использовать их вне функции, мы получим следующую ошибку.
Мы пытались использовать локальные переменные вне их области видимости; программа выдала NameError.
Глобальные переменные
Глобальные переменные могут использоваться во всей программе, и их область действия распространяется на всю программу. Мы можем использовать глобальные переменные внутри или вне функции.
Переменная, объявленная вне функции, по умолчанию является глобальной переменной. Python предоставляет ключевое слово global для использования глобальной переменной внутри функции. Если мы не используем ключевое слово global, функция рассматривает ее как локальную переменную. Давайте разберемся в следующем примере.
В приведенном выше коде мы объявили глобальную переменную x и присвоили ей значение. Затем мы определили функцию и получили доступ к объявленной переменной, используя ключевое слово global внутри функции. Теперь мы можем изменить значение. Затем мы присвоили переменной x новое строковое значение. Теперь мы вызвали функцию и приступили к печати x. Она напечатала новое присвоенное значение x.
Удаление переменных
Мы можем удалить переменную с помощью ключевого слова del. Синтаксис приведен ниже.
В следующем примере мы создаем переменную x и присваиваем ей значение. Мы удалили переменную x и напечатали ее, получаем ошибку «переменная x не определена». Переменная x больше не будет использоваться в будущем.
Максимально возможное значение переменной в Python
В отличие от других языков программирования, Python не имеет типов данных long int или float. Он обрабатывает все целочисленные значения как тип данных int. Здесь возникает вопрос: какое максимально возможное значение может содержать переменная в Python? Рассмотрим следующий пример.
Python не имеет специального типа данных для хранения больших чисел.
Печать одиночных и множественных переменных в Python
Мы можем распечатать несколько переменных в одном операторе печати. Ниже приведен пример одно- и многократной печати значений.
Локальные и глобальные переменные
В программировании особое внимание уделяется концепции о локальных и глобальных переменных, а также связанное с ними представление об областях видимости. Соответственно, локальные переменные видны только в локальной области видимости, которой может выступать отдельно взятая функция. Глобальные переменные видны во всей программе. «Видны» – значит, известны, доступны. К ним можно обратиться по имени и получить связанное с ними значение.
К глобальной переменной можно обратиться из локальной области видимости. К локальной переменной нельзя обратиться из глобальной области видимости, потому что локальная переменная существует только в момент выполнения тела функции. При выходе из нее, локальные переменные исчезают. Компьютерная память, которая под них отводилась, освобождается. Когда функция будет снова вызвана, локальные переменные будут созданы заново.
Вернемся к нашей программе из прошлого урока, немного упростив ее для удобства:
Сколько здесь переменных? Какие из них являются глобальными, а какие – локальными?
К локальной области относятся тела функций. Если, находясь в глобальной области видимости, мы попытаемся обратиться к локальной переменной, то возникнет ошибка:
Однако мы можем обращаться из функций к глобальным переменным:
Наши функции не совсем идеальны. Они должны вычислять площади фигур, но выводить результат на экран им не следовало бы. Вполне вероятна ситуация, когда результат нужен для внутренних нужд программы, для каких-то дальнейших вычислений, а выводить ли его на экран – вопрос второстепенный.
Если функции не будут выводить, а только вычислять результат, то его надо где-то сохранить для дальнейшего использования. Для этого подошли бы глобальные переменные. В них можно записать результат. Напишем программу вот так:
Итак, мы ввели в программу глобальную переменную result и инициировали ее нулем. В функциях ей присваивается результат вычислений. В конце программы ее значение выводится на экран. Мы ожидаем, что программа будет прекрасно работать. Однако…
… что-то пошло не так.
Когда функция завершает свою работу, то значение локальной result теряется, а глобальная не была изменена.
На самом деле можно принудительно обратиться к глобальной переменной. Для этого существует команда global :
В таком варианте программа будет работать правильно.
Однако менять значения глобальных переменных в теле функции – плохая практика. В больших программах программисту трудно отследить, где, какая функция и почему изменила их значение. Программист смотрит на исходное значение глобальной переменной и может подумать, что оно остается таким же. Сложно заметить, что какая-то функция поменяла его. Подобное ведет к логическим ошибкам.
Чтобы избавиться от необходимости использовать глобальные переменные, для функций существует возможность возврата результата своей работы в основную ветку программы. И уже это полученное из функции значение можно присвоить глобальной переменной в глобальной области видимости. Это делает программу более понятной.
Как функция принимает и возвращает данные, будет рассмотрено в следующих уроках.
Практическая работа
В языке Python можно внутри одной функции определять другую. Напишите программу по следующему описанию.
Как вы думаете, можно ли из основной ветки программы вызвать функцию, вложенную в другую функцию? Почему?
Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса