Как сделать переменную глобальной python

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

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

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

Пример

Создайте переменную вне функции и используйте ее внутри функции

def myfunc():
&nbspprint(«Python это » + x)

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

Пример

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

def myfunc():
x = «фантастика»
print(«Python это » + x)

print(«Python это » + x)

Глобальное ключевое слово

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

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

Пример

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

def myfunc():
global x
x = «фантастика»

print(«Python это » + x)

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

Пример

Чтобы изменить значение глобальной переменной внутри функции, обратитесь к переменной с помощью ключевого слова global :

def myfunc():
global x
x = «фантастика»

print(«Python это » + x)

Мы только что запустили
SchoolsW3 видео

ВЫБОР ЦВЕТА

курс сегодня!

Сообщить об ошибке

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

Ваше предложение:

Спасибо Вам за то, что помогаете!

Ваше сообщение было отправлено в SchoolsW3.

ТОП Учебники

ТОП Справочники

ТОП Примеры

Получить сертификат

SchoolsW3 оптимизирован для бесплатного обучения, проверки и подготовки знаний. Примеры в редакторе упрощают и улучшают чтение и базовое понимание. Учебники, ссылки, примеры постоянно пересматриваются, чтобы избежать ошибок, но не возможно гарантировать полную правильность всего содержания. Некоторые страницы сайта могут быть не переведены на РУССКИЙ язык, можно отправить страницу как ошибку, так же можете самостоятельно заняться переводом. Используя данный сайт, вы соглашаетесь прочитать и принять Условия к использованию, Cookies и политика конфиденциальности.

Руководство по глобальным переменным

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

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

Разберемся с этими понятиями на примере.

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

 
 
def sum(): a = 10 # локальные переменные b = 20 c = a + b print("Сумма:", c) sum()
Переменная объявлена внутри функции и может использоваться только в ней. Получить доступ к этой локальной функции в других нельзя.
Для решения этой проблемы используются глобальные переменные.
Теперь взгляните на этот пример с глобальными переменными:
 
 
a = 20 # определены вне функции b = 10 def sum(): c = a + b # Использование глобальных переменных print("Сумма:", c) def sub(): d = a - b # Использование глобальных переменных print("Разница:", d) sum() sub()
Сумма: 30 Разница: 10
В этом коде были объявлены две глобальные переменные: a и b . Они используются внутри функций sum() и sub() . Обе возвращают результат при вызове.






Если определить локальную переменную с тем же именем, то приоритет будет у нее. Посмотрите, как в функции msg это реализовано.
 
 
def msg(): m = "Привет, как дела?" print(m) msg() m = "Отлично!" # глобальная переменная print(m)
Привет, как дела? Отлично!
Здесь была объявлена локальная переменная с таким же именем, как и у глобальной. Сперва выводится значение локальной, а после этого — глобальной.
Ключевое слово global
Python предлагает ключевое слово global , которое используется для изменения значения глобальной переменной в функции. Оно нужно для изменения значения. Вот некоторые правила по работе с глобальными переменными.
Правила использования global

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

Пример без использования глобального ключевого слова.
 
 
c = 10 def mul(): c = c * 10 print(c) mul()
line 5, in mul c = c * 10 UnboundLocalError: local variable 'c' referenced before assignment
Этот код вернул ошибку, потому что была предпринята попытка присвоить значение глобальной переменной. Изменять значение можно только с помощью ключевого слова global .






 
c = 10 def mul(): global c c = c * 10 print("Значение в функции:", c) mul() print("Значение вне функции:", c)
Значение в функции: 100 Значение вне функции: 100
Здесь переменная c была объявлена в функции mul() с помощью ключевого слова global . Ее значение умножается на 10 и становится равным 100. В процессе работы программы можно увидеть, что изменение значения внутри функции отражается на глобальном значении переменной.
Глобальные переменные в модулях Python
Преимущество использования ключевого слова global — в возможности создавать глобальные переменные и передавать их между модулями. Например, можно создать name.py, который бы состоял из глобальных переменных. Если их изменить, то изменения повлияют на все места, где эти переменные встречаются.
1. Создаем файл name.py для хранения глобальных переменных:
Локальные и глобальные переменные
В программировании особое внимание уделяется концепции о локальных и глобальных переменных, а также связанное с ними представление об областях видимости. Соответственно, локальные переменные видны только в локальной области видимости, которой может выступать отдельно взятая функция. Глобальные переменные видны во всей программе. "Видны" – значит, известны, доступны. К ним можно обратиться по имени и получить связанное с ними значение.
К глобальной переменной можно обратиться из локальной области видимости. К локальной переменной нельзя обратиться из глобальной области видимости, потому что локальная переменная существует только в момент выполнения тела функции. При выходе из нее, локальные переменные исчезают. Компьютерная память, которая под них отводилась, освобождается. Когда функция будет снова вызвана, локальные переменные будут созданы заново.






Вернемся к нашей программе из прошлого урока, немного упростив ее для удобства:
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 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)
Итак, мы ввели в программу глобальную переменную result и инициировали ее нулем. В функциях ей присваивается результат вычислений. В конце программы ее значение выводится на экран. Мы ожидаем, что программа будет прекрасно работать. Однако…
1-прямоугольник, 2-треугольник: 2 Основание: 6 Высота: 4.5 Площадь: 0.00
… что-то пошло не так.
Дело в том, что в Python присвоение значения переменной совмещено с ее объявлением. (Во многих других языках это не так.) Поэтому, когда имя result впервые упоминается в локальной области видимости, и при этом происходит присваивание ей значения, то создается локальная переменная result . Это другая переменная, никак не связанная с глобальной result .
Когда функция завершает свою работу, то значение локальной result теряется, а глобальная не была изменена.






Когда мы вызывали внутри функции переменную figure , то ничего ей не присваивали. Наоборот, мы запрашивали ее значение. Интерпретатор Питона искал ее значение сначала в локальной области видимости и не находил. После этого шел в глобальную и находил.
В случае с 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 2 . В теле cylinder у пользователя спрашивается, хочет ли он получить только площадь боковой поверхности цилиндра, которая вычисляется по формуле 2πrh, или полную площадь цилиндра. В последнем случае к площади боковой поверхности цилиндра должен добавляться удвоенный результат вычислений функции circle() .
Как вы думаете, можно ли из основной ветки программы вызвать функцию, вложенную в другую функцию? Почему?






Примеры решения и дополнительные уроки в pdf-версии курса
X Скрыть Наверх
Python. Введение в программирование
Глобальные, локальные и нелокальные переменные в 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() .

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

СodeСhick.io - простой и эффективный способ изучения программирования.
2023 © ООО "Алгоритмы и практика"


Похожие публикации:

Как открыть предыдущую сессию в mozilla firefox
Как подключить авито к битрикс
Как слить воды со стиральной машины indesit
Какие существуют способы выделения блоков в mathcad