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

Как создать и объявить глобальную переменную в Python

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

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

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

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

# example of local variable def sum(): a = 10 # local variables b = 20 c = a + b print("the sum is:", c) sum() # function calling

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

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

# example of a global variable a = 20 # defined outside the function b = 10 def sum(): c = a + b # Using global variables print("The sum is:", c) def sub(): d = a - b # using global variables print("The sub is:", d) sum() # function calling sub()

The sum is: 30 The sub is: 10

В приведенном выше коде мы определили две глобальные переменные a и b вне функций. Мы использовали их внутри функций sum() и sub(). Обе функции вернули результат при вызове.

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

def msg(): m = "Hello, how are you?" print(m) msg() m = "I am fine" # global scope print(m)

Hello, how are you? I am fine

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

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

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

Правила глобальных ключевых слов:

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

Пример – без глобального ключевого слова:

# The example of without using the global keyword c = 10 def mul(): # Multiply by 10 c = c * 10 print(c) mul()

line 8, in mul c = c * 10 UnboundLocalError: local variable 'c' referenced before assignment

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

Пример – с глобальным ключевым словом:

# The example using the global keyword c = 10 def mul(): global c # Multiply by 10 c = c * 10 print("The value inside function: ", c) mul() print('The value outside the function: ', c)

The value inside function: 100 The value outside the function: 100

В приведенном выше примере мы определили переменную c в функции mul() с помощью ключевого слова global. Значение c умножается на 10; следовательно, возвращается 200. Мы видим в выходных данных, что изменение значения внутри функции отражается на значении вне глобальной переменной.

Глобальные переменные в модулях Python

Преимущество ключевого слова global заключается в создании глобальных переменных и совместном использовании их между различными модулями. Например, мы создаем name.py, который состоит из глобальных переменных. Если мы изменим эти переменные, то это изменение отразится повсюду. Давайте разберемся в следующем примере.

Код – 1: Создайте файл name.py для хранения глобальных переменных.

a = 10 b = 20 msg = "Hello World"

Код – 2: Создайте файл change.py для изменения глобальных переменных.

import name name.a = 15 name.b = 26 name.msg = "Welcome to JavaTpoint"

Здесь мы изменили значение a, b и msg. Эти глобальные переменные были определены в файле name.py, и мы импортировали name и получили доступ к этим переменным.

Код – 3: Создайте файл result.py для печати измененных глобальных переменных.

import name import change print(change.a) print(change.b) print(change.msg)

15 26 Welcome to JavaTpoint

Ключевое слово global во вложенных функциях

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

# The example of global in nested function def add(): a = 15 def modify(): global a a = 20 print("Before modifying : ", a) print("Making change") modify() print("After modifying: ", a) add() print("value of x: ", a)

Before modifying : 15 Making change After modifying: 15 value of x 20

В приведенном выше коде значение внутри add() принимает значение локальной переменной x = 15. В функции modify() мы присвоили x = 20 с помощью ключевого слова global. Это изменение отражено в переменной функции add().

Источник

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

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

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

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

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

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

def print_list(some_list): for element in some_list: print(element)

Здесь element и some_list – локальные переменные, которые видны только внутри функции, и которые не могут использоваться за ее пределами с теми значениями, которые были им присвоены внутри функции при ее работе. То есть, если мы в основном теле программы вызовем print(element) , то получим ошибку:

NameError: name 'element' is not defined

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

def print_list(some_list): for element in some_list: print(element) element = 'q' print_list([1, 2, 3]) print(element) 

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

def print_list(some_list): for element in sudden_list: print(element) sudden_list = [0, 0, 0] print_list([1, 2, 3])

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

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

SUDDEN_LIST = [0, 0, 0] def print_list(some_list): for element in SUDDEN_LIST: print(element) print_list([1, 2, 3]) 

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

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

В Python есть ключевое слово global , которое позволяет изменять изнутри функции значение глобальной переменной. Оно записывается перед именем переменной, которая дальше внутри функции будет считаться глобальной. Как видно из примера, теперь значение переменной candy увеличивается, и обратите внимание на то, что мы не передаем ее в качестве аргумента функции get_candy() .

candy = 5 def get_candy(): global candy candy += 1 print('У меня <> конфет.'.format(candy)) get_candy() get_candy() print(candy)

 У меня 6 конфет. У меня 7 конфет. 7 

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

Лайфхак: Чтобы не мучиться с именованием переменных, вы можете вынести основной код программы в функцию main() , тогда все переменные, которые будут объявлены внутри этой функции останутся локальными и не будут портить глобальную область видимости, увеличивая вероятность допустить ошибку.

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

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

def get_candy(): candy = 5 def increment_candy(): nonlocal candy candy += 1 return candy return increment_candy result = get_candy()() print('Всего <> конфет.'.format(result))

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

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

1. Изнутри функции видны переменные, которые были определены и внутри нее и снаружи. Переменные, определенные внутри – локальные, снаружи – глобальные.
2. Снаружи функций не видны никакие переменные, определенные внутри них.
3. Изнутри функции можно изменять значение переменных, которые определены в глобальной области видимости с помощью спецификатора global .
4. Изнутри вложенной функции с помощью спецификатора nonlocal можно изменять значения переменных, которые были определены во внешней функции, но не находятся в глобальной области видимости.

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

Источник