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

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

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

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

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

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

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

Вывод:

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

Вывод:

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

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

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

Вывод:

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

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

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

Вывод:

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

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

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

Вывод:

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

Вывод:

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

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

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

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

Вывод:

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

Источник

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

В программировании особое внимание уделяется концепции о локальных и глобальных переменных, а также связанное с ними представление об областях видимости. Соответственно, локальные переменные видны только в локальной области видимости, которой может выступать отдельно взятая функция. Глобальные переменные видны во всей программе. “Видны” – значит, известны, доступны. К ним можно обратиться по имени и получить связанное с ними значение.

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

Вернемся к нашей программе из прошлого урока, немного упростив ее для удобства:

Сколько здесь переменных? Какие из них являются глобальными, а какие – локальными?

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

Однако мы можем обращаться из функций к глобальным переменным:

Наши функции не совсем идеальны. Они должны вычислять площади фигур, но выводить результат на экран им не следовало бы. Вполне вероятна ситуация, когда результат нужен для внутренних нужд программы, для каких-то дальнейших вычислений, а выводить ли его на экран – вопрос второстепенный.

Если функции не будут выводить, а только вычислять результат, то его надо где-то сохранить для дальнейшего использования. Для этого подошли бы глобальные переменные. В них можно записать результат. Напишем программу вот так:

Итак, мы ввели в программу глобальную переменную result и инициировали ее нулем. В функциях ей присваивается результат вычислений. В конце программы ее значение выводится на экран. Мы ожидаем, что программа будет прекрасно работать. Однако…

… что-то пошло не так.

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

На самом деле можно принудительно обратиться к глобальной переменной. Для этого существует команда global :

В таком варианте программа будет работать правильно.

Однако менять значения глобальных переменных в теле функции – плохая практика. В больших программах программисту трудно отследить, где, какая функция и почему изменила их значение. Программист смотрит на исходное значение глобальной переменной и может подумать, что оно остается таким же. Сложно заметить, что какая-то функция поменяла его. Подобное ведет к логическим ошибкам.

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

Как функция принимает и возвращает данные, будет рассмотрено в следующих уроках.

Практическая работа

В языке Python можно внутри одной функции определять другую. Напишите программу по следующему описанию.

Как вы думаете, можно ли из основной ветки программы вызвать функцию, вложенную в другую функцию? Почему?

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Источник

Как использовать global и nonlocal переменные в Python

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

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

Области видимости в Python

Прежде чем мы сможем начать, мы сначала должны коснуться областей. Для тех из вас, кто не знаком, “область видимости” относится к контексту, в котором определяется переменная и как к ней можно получить доступ или изменить или, более конкретно, откуда она может быть получена.

И в программировании, как и в жизни, важен контекст.

Ссылаясь на Python прямо сейчас, вы можете сделать вывод из контекста, что я имею в виду язык программирования. Однако в другом контексте Python может быть ссылкой на змею или комедийную группу.

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

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

Как и ожидалось, этот код выведет нам:

Но что происходит, когда мы перемещаем оператор печати за пределы функции?

Мы получаем ошибку:

Чтобы наша программа могла понимать переменную глобально (вне функции), нам нужно определить ее глобально.

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

Что, если вместо первоначального определения нашей переменной внутри функции мы переместим ее наружу и инициализируем там?

В этом случае мы можем ссылаться на нее вне функции, и все работает.

Это потому, что fruit мы изменили в функции shopping_list() создав новую локальную переменную. Мы создали ее, присвоили ей значение и после этого ничего не сделали. Это фактически полностью избыточный код. print() выводит значение глобальной переменной.

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

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

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

Мы могли бы даже объявить глобальную переменную в одной функции и получить к ней доступ в другой, не определяя ее как глобальную во второй:

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

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

Мы быстро рассмотрим пример потенциальной проблемы, прежде чем перейти к некоторым из способов, которыми глобальные переменные могут быть полезны в вашем собственном коде:

Запустив приведенный выше код, мы получим следующий вывод:

Если мы изменим этот порядок или попытаемся повторить его позже, мы столкнемся с большой проблемой:

Теперь это выводит:

А именно, теперь fruit это строка, которая будет повторяться. Что еще хуже, эта ошибка не проявляется, пока, по-видимому, не станет слишком поздно. Первый код вроде бы работал нормально.

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

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

Поскольку в большинстве наших примеров мы использовали списки покупок и фрукты, мы могли бы подумать о функции оформления заказа, которая суммирует сумму покупок:

Запустив приведенный выше код, мы получим результат:

Таким образом, глобальная переменная count по-прежнему является локальной для внешней функции и не влияет (или не существует) на более высоком уровне. Это дает вам некоторую свободу в добавлении модификаторов к вашим функциям.

Вы всегда можете подтвердить это, попробовав распечатать pct_off не с помощью метода подсчета покупок:

Заключение

Источник

Переменные 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

Мы можем распечатать несколько переменных в одном операторе печати. Ниже приведен пример одно- и многократной печати значений.

Источник

Все, что вы хотели узнать про области видимости в Python, но стеснялись спросить

В преддверии старта нового потока по курсу «Разработчик Python», решили поговорить про области видимости в Python. Что из этого вышло? — Читайте в материале ниже.

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

Области видимости определяют, в какой части программы мы можем работать с той или иной переменной, а от каких переменная «скрыта». Крайне важно понимать, как использовать только те значения и переменные, которые нам нужны, и как интерпретатор языка себя при этом ведет. А еще мы посмотрим, как обходить ограничения, накладываемые областями видимости на действия с переменными. В Python существует целых 3 области видимости:

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

Локальная область видимости

Рассмотрим функцию, которая выведет список some_list поэлементно:

Теперь мы поступим следующим образом:

Здесь переменная element внутри функции и переменная с таким же именем вне ее – это две разные переменные, их значения не перекрещиваются и не взаимозаменяются. Они называются одинаково, но ссылаются на разные объекты в памяти. Более того, переменная с именем element внутри функции живет столько же, сколько выполняется функция и не больше. Но будьте аккуратны с тем, чтобы давать локальным и глобальным переменным одинаковые имена, сейчас покажу почему:

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

Здесь важно поговорить о константах. Интерпретатору Python нет разницы как вы называете переменную, поэтому код выше будет лучше переписать в следующем виде:

Теперь все на своих местах. Дело в том, что в Python нельзя каким-то образом строго определить константу, как объект, который не должен быть изменен. Так что то, как вы используете значение переменной, имя которой записано заглавными буквами, остается лишь на вашей совести. Другой вопрос, что таким способом записанная переменная даст понять тому, кто будет читать ваш код, что переменная нигде изменяться не будет. Или по крайней мере не должна.

Глобальная область видимости

В результате получим:

Однако менять значение глобальной переменной изнутри функции – не лучшая практика и лучше так не делать, поскольку читаемости кода это не способствует. Чем меньше то, что происходит внутри функции будет зависеть от глобальной области видимости, тем лучше.

Нелокальная область видимости

Насколько это полезно вам предстоит решить самостоятельно. Больше примеров вы можете найти здесь.

В качестве вывода можно сформулировать несколько правил:

Источник