Команда глобал в питоне

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

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

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

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

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

 
 
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()
 
В этом коде были объявлены две глобальные переменные: 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 для хранения глобальных переменных:
 
Источник
 
Область видимости в Python
 
 
Вы, наверное, не раз слышали термин область видимости, когда изучали программирование. Это весьма важная тема, незнание которой может привести к достаточно запутанным ошибкам. Область видимости указывает интерпретатору, когда наименование (или переменная) видимо. Другими словами, область видимости определяет, когда и где вы можете использовать свои переменные, функции, и т.д. Если вы попытаетесь использовать что-либо, что не является в вашей области видимости, вы получите ошибку NameError.
 
Python содержит три разных типа области видимости:
 
 
Локальная область видимости
 
Глобальная область видимости
 
Нелокальная область видимости (была добавлена в Python 3)
 
 
Локальная область видимости
 
Локальная область видимости наиболее часто используется в Python. Когда мы создаем переменную в блоке кода, она будет разрешена при помощи ближайшей области видимости, или областей. Группирование всех этих областей известно как среда блоков кода. Другими словами, все назначения выполняются в локальной области по умолчанию. Если вам нужно что-то другое, тогда вам нужно настроить свою переменную на глобальную или нелокальную область, которые мы рассмотрим немного позже. Сейчас мы создадим простой пример, используя интерпретатор Python, в котором демонстрируется назначение локальной области видимости.
 
Источник
 
Ключевое слово global в Python
 
В этой статье вы узнаете, для чего нужно ключевое слово global и когда его использовать. А еще мы подробнее поговорим о глобальных переменных.
 
Поэтому перед прочтением этой статьи ознакомьтесь со статьей «Глобальные, локальные и нелокальные переменные в Python».
 
Что это такое
 
Ключевое слово global позволяет изменять переменную вне текущей области видимости в Python. global используется для создания глобальной переменной и изменения ее в локальной области видимости.
 
Что нужно знать прежде, чем работать с global
 
 
Когда мы создаем переменную внутри функции, она по умолчанию является локальной.
 
Когда мы определяем переменную вне функции, она по умолчанию является глобальной. В этом случае не нужно использовать ключевое слово global .
 
Ключевое слово global нужно для получения доступа к глобальной переменной и изменения ее внутри функции, то есть внутри локальной области видимости.
 
Использовать ключевое слово global вне функции бессмысленно.
 
 
Как использовать global
 
Пример 1. Получаем доступ к глобальной переменной внутри функции
 
c = 1 # глобальная переменная def add(): print(c) add() 
 
Все работает! Но что если нам нужно изменить глобальную переменную внутри функции?
 
Пример 2. Изменяем глобальную переменную внутри функции
 
c = 1 # глобальная переменная def add(): c = c + 2 # прибавляем 2 к c print(c) add() 
 
UnboundLocalError: local variable 'c' referenced before assignment
 
Python сообщает нам, что мы использовали локальную переменную c до ее объявления. Дело в том, что получить доступ к глобальной переменной внутри функции мы можем, а вот изменять ее в локальной области видимости — уже нет.
 
Для этого и нужно ключевое слово global .
 
Пример 3. Изменяем глобальную переменную внутри функции с помощью global
 
c = 0 # глобальная переменная def add(): global c c = c + 2 # прибавляем 2 к c print("Внутри функции add():", c) add() print("В глобальной области видимости:", c) 
 
Внутри функции add(): 2 В глобальной области видимости: 2
 
В приведенной выше программе мы определяем c как глобальную переменную внутри функции add() с помощью ключевого слова `global`.
 
Внутри функции мы также увеличиваем переменную c ` на 2, то есть выполняем действие c = c + 2 . И, наконец, выводим на экран глобальную переменную c .
 
Как мы видим, глобальная переменная c изменилась не только внутри функции, но и в глобальной области видимости. И там, и там c = 2 .
 
Глобальные переменные в модулях Python
 
В Python принято создавать единый модуль config.py для хранения глобальных переменных и обмена информацией между модулями Python в одной программе.
 
Вот как можно использовать глобальные переменные между модулями Python.
 
Пример 4. Используем глобальную переменную между модулями
 
Создаем файл config.py , в нем будем хранить глобальные переменные.
 
Создаем файл update.py , чтобы изменять глобальные переменные.
 
import config config.a = 10 config.b = "алфавит"
 
Создаем файл main.py . Его будем использовать, чтобы отслеживать изменения значений глобальных переменных.
 
Теперь запустим файл main.py .
 
Итак, мы создали 3 файла: config.py , update.py , и main.py .
 
Модуль config.py хранит глобальные переменные a и b . В файле update.py мы импортируем модуль config.py и изменяем значения a и b . Точно так же в файл main.py мы импортируем config.py и update.py . Наконец, мы печатаем и проверяем значения глобальных переменных независимо от того, изменились они или нет.
 
Как использовать global во вложенных функция
 
Пример 5. Используем глобальные переменные во вложенных функциях
 
def foo(): x = 20 def bar(): global x x = 25 print("До вызова bar(): ", x) print("Вызываем bar()") bar() print("После вызова bar(): ", x) foo() print("x в глобальной областим видимости: ", x)
 
До вызова bar(): 20 Вызываем bar() После вызова bar(): 20 x в глобальной области видимости: 25
 
В приведенной выше программе мы объявили глобальную переменную внутри вложенной функции bar() . Внутри функции foo() ключевое слово global никак не влияет на переменную x .
 
До и после вызова bar() переменная x принимает значение локальной переменной, т. е. x = 20 . Вне функции foo() переменная x примет значение, определенное в функции x , т. е. x = 25 . Так произойдет потому, что мы использовали ключевое слово global , чтобы создать глобальную переменную x внутри функции bar() , то есть в локальной области видимости.
 
Если мы сделаем какие-либо изменения внутри функции bar() , изменения отобразятся и за пределами локальной области видимости, то есть за пределами функции foo() .
 
Источник
 
Читайте также:  Java Script