Локальные и глобальные переменные: Глобальные и локальные переменные — testing.swiftbook

Локальные и глобальные переменные. Урок 12 курса «Python. Введение в программирование»

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

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

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

 def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    print("Площадь: %. 2f" % (a * b))
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    print("Площадь: %.2f" % (0.5 * a * h))
 
 
figure = input("1-прямоугольник, 2-треугольник: ")
 
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()

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

Здесь пять переменных. Глобальной является только figure. Переменные a и b из функции rectangle, а также a и h из triangle – локальные. При этом локальные переменные с одним и тем же идентификатором a, но объявленные в разных функциях, – разные переменные.

Следует отметить, что идентификаторы rectangle и triangle, хотя и не являются именами переменных, а представляют собой имена функций, также имеют область видимости. В данном случае она глобальная, так как функции объявлены непосредственно в основной ветке программы.

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

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

…
elif figure == '2':
    triangle()
 
print(a)

Пример выполнения:

1-прямоугольник, 2-треугольник: 2
Основание: 4
Высота: 5
Площадь: 10.00
Traceback (most recent call last):
  File "test.py", line 17, in <module>
    print(a)
NameError: name 'a' is not defined

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

def rectangle():
    a = float(input("Ширина %s: " % figure))
    b = float(input("Высота %s: " % figure))
    print("Площадь: %.2f" % (a * b))
 
def triangle():
    a = float(input("Основание %s: " % figure))
    h = float(input("Высота %s: " % figure))
    print("Площадь: %. 2f" % (0.5 * a * h))
 
 
figure = input("1-прямоугольник, 2-треугольник: ")
 
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()

Пример выполнения:

1-прямоугольник, 2-треугольник: 1
Ширина 1: 6.35
Высота 1: 2.75
Площадь: 17.46

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

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

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

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    result = a * b
 
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    result = 0. 5 * a * h
 
 
result = 0
 
figure = input("1-прямоугольник, 2-треугольник: ")
 
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()
 
print("Площадь: %.2f" % result)

Итак, мы ввели в программу глобальную переменную

1-прямоугольник, 2-треугольник: 2
Основание: 6
Высота: 4.5
Площадь: 0.00

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

Дело в том, что в Python присвоение значения переменной совмещено с ее объявлением. (Во многих других языках это не так.) Поэтому, когда имя result впервые упоминается в локальной области видимости, и при этом происходит присваивание ей значения, то создается локальная переменная result. Это другая переменная, никак не связанная с глобальной result.

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

Когда мы вызывали внутри функции переменную

В случае с result он ничего не ищет. Он выполняет вычисления справа от знака присваивания, создает локальную переменную result, связывает ее с полученным значением.

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

def rectangle():
    a = float(input("Ширина: "))
    b = float(input("Высота: "))
    global result
    result = a * b
 
 
def triangle():
    a = float(input("Основание: "))
    h = float(input("Высота: "))
    global result
    result = 0.5 * a * h
 
 
result = 0
 
figure = input("1-прямоугольник, 2-треугольник: ")
 
if figure == '1':
    rectangle()
elif figure == '2':
    triangle()
 
print("Площадь: %.
 
  2f" % result)

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

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

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

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

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

В основной ветке программы вызывается функция cylinder(), которая вычисляет площадь цилиндра. В теле cylinder определена функция circle, вычисляющая площадь круга по формуле πr². В теле cylinder у пользователя спрашивается, хочет ли он получить только площадь боковой поверхности цилиндра, которая вычисляется по формуле 2πrh, или полную площадь цилиндра. В последнем случае к площади боковой поверхности цилиндра должен добавляться удвоенный результат вычислений функции circle().

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

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

Локальные и глобальные переменные в Python • Школа программирования Pylot.me

2022-10-17

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

В Python для переменных существует 4-ре следующие области видимости: локальная, нелокальная, глобальная и системная.

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

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

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

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

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

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

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

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

>>> privetstviye = "Привет земляне!"

Затем, давайте объявим простенькую функцию prosmotr_privetstviya(), которая будет выводить на печать нашу раннее объявленную переменную privetstviye:

>>> def prosmotr_privetstviya():
...     print(privetstviye)
...

Как и следовало ожидать, в результате вызова вышеназванной функции мы увидим выведенную на дисплей строку “Привет земляне!”:

>>> prosmotr_privetstviya()
Привет земляне!

Хотя переменная privetstviye в функции prosmotr_privetstviya() и не была объявлена, данная функция все-таки без проблем смогла ее вывести внутри себя. Это объясняется тем, что данную переменную мы объявили

Изменение значений у локальных и глобальных переменных

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

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

>>> def izmenyayemoye_privetstviya(utochneniye):
...     privetstviye = f"Привет {utochneniye}!"
...     print(privetstviye)
...

Как вы думаете, что нам выведет функция izmenyayemoye_privetstviya() с переданным, например, аргументом “инопланетяне”, а что покажет непосредственно сама переменная privetstviye, выведенная через стандартную функцию print(). Давайте для наглядности приведем полный листинг кода с этим примером:

privetstviye = "Привет земляне!"
def izmenyayemoye_privetstviya(utochneniye):
    privetstviye = f"Привет {utochneniye}!"
    print(privetstviye)
izmenyayemoye_privetstviya("инопланетяне")
print(privetstviye)
# Привет инопланетяне!
# Привет земляне!

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

Затенение переменных

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

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

Иногда в Python специально для оптимизации кода используют вышеописанные особенности сочетания одноименных глобальных и локальных переменных, а сам процесс создания этих переменных с одинаковыми именами называют затенением. Вмести с тем, следует отметить, что многие опытные разработчики все-таки не склонны применять практику затенения переменных поскольку видят в ней негативное влияние на читабельность и логику восприятия разрабатываемого ими кода.

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

Интуитивно, на уровне подсознание, мы где-то уже почти осознали то, что внутри любого программного блока априори не может быть двух переменных с одинаковыми именами, одна из которых трактовалась бы интерпретатором, как глобальная, а другая, как локальная переменная. Но, давайте посмотрим, как будет реагировать наш интерпретатор в случае реального наличия такой ситуации. Для этого немного изменим раннее объявленную нами функцию izmenyayemoye_privetstviya() таким образом, чтобы прежде она выводила бы на дисплей строку приветствия из нашей глобальной переменной privetstviye, а затем переменной с тем же именем присваивала бы другую строку приветствие сформированную с учетом значения, полученного из своего аргумента. В конце же данной функции мы снова попытаемся вывести уже измененное содержимое переменной privetstviye на дисплей.

>>> def izmenyayemoye_privetstviya(utochneniye):
...     print(privetstviye)
...     privetstviye = f"Привет {utochneniye}!"
...     print(privetstviye)
...

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

izmenyayemoye_privetstviya("инопланетяне")

у нас на дисплее сначала выведется содержание нашей предварительно инициализированной глобальной переменной (Привет земляне!), а затем содержание нашей локальной переменной (Привет инопланетяне!), которая была инициализирована прямо внутри нашей функции. Но, на самом деле произойдет нечто иное:

privetstviye = "Привет земляне!"
def izmenyayemoye_privetstviya(utochneniye):
    print(privetstviye)
    privetstviye = f"Привет {utochneniye}!"
    print(privetstviye)
izmenyayemoye_privetstviya("инопланетяне")
# Traceback (most recent call last):
#   File "<stdin>", line 8, in <module>
#   File "<stdin>", line 4, in izmenyayemoye_privetstviya
# UnboundLocalError: cannot access local variable 'privetstviye' where it is not associated with a value

Фактически, при вызове первого print(privetstviye) в функции izmenyayemoye_privetstviya() мы в нашем примере получили исключение UnboundLocalError, гласящее о том, что локальная переменная privetstviye не может быть выведена на дисплей, так как она еще не инициализирована.

На первый взгляд данная ошибка может показаться несуразностью, ведь мы предварительно объявили и инициализировали privetstviye вне всяких программных блоков, как глобальную переменную. А тут, в ошибке выдается, что она якобы превратилась в локальную, да еще не инициализированную переменную? Но, на самом деле это объясняется тем, что, анализируя код нашей функции, интерпретатор Python прежде всего просматривает операторы присваивания и, только потом отслеживает имена переменных, которым в нашем случае мы присвоили одинаковые имена privetstviye. Именно поэтому, видя в нашей функции оператор присвоения в отношении к переменной privetstviye, интерпретатор не только априори объявляет эту переменную локальной, но и любое другое упоминание ее имени в функции также воспринимает в качестве этой же локальной переменной.

Таким образом, в 4-й строке программы вместе со стандартной функцией print() у нас используется локальная переменная privetstviye, которая фактически инициализируется только на следующей, 5-й строке.

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

Выводы

Из данной статьи в отношении интерпретатора Python можно сделать следующие обобщающие выводы:

1. Использование значений глобальных переменных допускается в любом месте модуля (файла с программой), как внутри программных блоков (функций, классов, методов или процедур), так и вне их.
2. Значения локальных переменных внутри тех программных блоков, где они были объявлены могут без ограничений, как использоваться, так и изменяться.
3. В случае наличия в модули одноименных глобальных и локальных переменных, внутри программных блоков могут быть доступны лишь значения объявленных там локальных переменных. Этот процесс называется затенением переменных.
4. Внутри программных блоков каждая переменная должна однозначно восприниматься интерпретатором, либо как локальная, либо как глобальная. Двух одноименных переменных с разными областями видимости в интерпретаторе быть не может.
5. Оператор присвоения внутри программных блоков в случае одноименных глобальных и локальных переменных всегда глобальную переменную замещает локальной, что может привести к ошибки при использовании данной переменной до ее инициализации.

Практический Python для начинающих

Станьте junior Python программистом за 7 месяцев

 7 месяцев

Подробнее

В чем разница между локальной и глобальной переменной в python?

В чем разница между локальной и глобальной переменной в Python?

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

Область действия переменной

Область действия переменной — это, по сути, срок жизни этой переменной. Это участок кода, в котором находится переменная. В зависимости от сферы их применения переменные делятся на:

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

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

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

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

•  Глобальные переменные объявляются вне функций, тогда как локальные переменные объявляются внутри функций.
• Локальные переменные создаются, когда функция начинает выполнение, и теряются, когда функция завершается. С другой стороны, глобальные переменные создаются в начале выполнения программы и теряются при завершении программы.
• В отличие от глобальных переменных, локальные переменные не обеспечивают совместное использование данных.
• Хотя глобальные переменные хранятся в фиксированном месте, выбранном компилятором, локальные переменные хранятся в стеке.
• Для локальных переменных необходима передача параметров, но не для глобальных переменных.
• В Python глобальные переменные могут быть определены с использованием глобального ключевого слова, тогда как локальные переменные могут быть определены напрямую.

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

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

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

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

Пример:

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

Вывод:

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

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

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

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

Пример:

Давайте рассмотрим краткий пример определения глобальных переменных. Здесь мы просто обращаемся к глобальной переменной с помощью ключевого слова global.

Вывод:

Локальная переменная vs. Глобальные переменные

Давайте посмотрим на табличную разницу между локальной и глобальной переменной в Python

Примеры для понимания различий между локальной и глобальной переменной

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

Пример локальной переменной:

В этом примере мы создаем локальную переменную внутри функции и пытаемся получить доступ к этой локальной переменной вне функции.

Вывод:

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

Пример глобальной переменной:

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

Вывод:

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

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

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

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

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

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

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

Недостатки локальных переменных

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

Недостатки глобальных переменных

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

Какой из них полезнее?

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

Заключение

• Переменные играют очень важную роль в хранении данных и информации.
• Область видимости переменной — это, по сути, срок жизни этой переменной. Это участок кода, в котором находится переменная.
• Переменные делятся на:
  • Глобальные переменные
  • Локальные переменные
• Доступ к локальным переменным возможен только внутри функции или модуля, в котором они определены, в отличие от глобальных переменных, которые можно использовать во всей программе.
• Локальные переменные объявляются внутри функциональных блоков, тогда как глобальные переменные — это тип переменных, объявляемых вне каждой функции программы.
• Существует множество преимуществ и недостатков использования как локальных, так и глобальных переменных.
• Целесообразно избегать объявления бессмысленных глобальных переменных и использования локальных переменных для передачи данных и управления ими. Как правило, в Python рекомендуется использовать локальные переменные.

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

Улучшить статью

Сохранить статью

Нравится Статья

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

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

Локальные переменные в Python — это те, которые инициализируются внутри функции и принадлежат только этой конкретной функции. К нему нельзя получить доступ где-либо вне функции. Давайте посмотрим, как создать локальную переменную.

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

  NameError  : имя 's' не определено 

 Внутренняя функция Я люблю Geeksforgeeks
Внешняя функция Я люблю Geeksforgeeks 

 Я тоже. 
Я люблю Geeksforgeeks 

  UnboundLocalError  : локальная переменная 's', на которую ссылается перед присваиванием 

 Python великолепен! ГФГ
Ищите раздел Geeksforgeeks Python
Ищите Geeksforgeeks Python Section 

'Inside h() : ' 9026 6 , а)

 

 

печать ( 'глобальный:' , a)

f()

печать ( 'глобальный:' 90 266 , а)

г()

печать ( 'глобальный :' , a)

h()

печать ( 'glo бал: ' , а)

Выход

 глобальный : 1
Внутри f() : 1
глобальный : 1
Внутри g() : 2
глобальный : 1
Внутри h() : 3
глобальный : 3 

Разница между ч/б локальной переменной и.