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

Область видимости переменных в Python

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

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

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

Local Hello
NameError: name ‘message’ is not defined

Здесь переменная message является локальной переменной функции greet(), поэтому доступ к ней возможен только внутри этой функции. Именно поэтому в результате мы увидели сообщение об ошибке, когда попытались получить доступ к переменной message вне функции greet().

Чтобы решить эту проблему, мы можем сделать переменную message глобальной.

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

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

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

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

Поэтому перед прочтением этой статьи ознакомьтесь со статьей «Глобальные, локальные и нелокальные переменные в Python».

Что это такое

Ключевое слово global позволяет изменять переменную вне текущей области видимости в Python. global используется для создания глобальной переменной и изменения ее в локальной области видимости.

Что нужно знать прежде, чем работать с global

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

Как использовать global

Пример 1. Получаем доступ к глобальной переменной внутри функции

Вывод:

Все работает! Но что если нам нужно изменить глобальную переменную внутри функции?

Пример 2. Изменяем глобальную переменную внутри функции

Вывод:

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

Для этого и нужно ключевое слово global .

Пример 3. Изменяем глобальную переменную внутри функции с помощью global

Вывод:

В приведенной выше программе мы определяем c как глобальную переменную внутри функции add() с помощью ключевого слова `global`.

Внутри функции мы также увеличиваем переменную c ` на 2, то есть выполняем действие c = c + 2 . И, наконец, выводим на экран глобальную переменную c .

Как мы видим, глобальная переменная c изменилась не только внутри функции, но и в глобальной области видимости. И там, и там c = 2 .

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

В Python принято создавать единый модуль config.py для хранения глобальных переменных и обмена информацией между модулями Python в одной программе.

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

Пример 4. Используем глобальную переменную между модулями

Создаем файл config.py , в нем будем хранить глобальные переменные.

Создаем файл update.py , чтобы изменять глобальные переменные.

Создаем файл 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. Используем глобальные переменные во вложенных функциях

Вывод:

В приведенной выше программе мы объявили глобальную переменную внутри вложенной функции bar() . Внутри функции foo() ключевое слово global никак не влияет на переменную x .

До и после вызова bar() переменная x принимает значение локальной переменной, т. е. x = 20 . Вне функции foo() переменная x примет значение, определенное в функции x , т. е. x = 25 . Так произойдет потому, что мы использовали ключевое слово global , чтобы создать глобальную переменную x внутри функции bar() , то есть в локальной области видимости.

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

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

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

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

• Локальная
• Глобальная
• Нелокальная

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Python Global Variables

In this tutorial, you’ll learn what is a global variable in Python and how to use them effectively.

Goals of this lesson:

• Understand what is a global variable in Python with examples
• Use global variables across multiple functions
• Learn how to use the global keyword to modify the global variables
• Learn to use global variables across Python modules/files
• Understand the use of globals() function
• Use global variables inside a nested function

Table of contents

What is a Global Variable in Python

In Python, a variable declared outside the function or in global scope is known as a global variable. We can use global variables both inside and outside the function.

The scope of a global variable is broad. It is accessible in all functions of the same module.

Python global variables

Let’s understand it with an example.

Example:

In this example, we declared a global variable name with the value ‘Jessa’. The same global variable name is accessible to everyone, both inside of functions and outside.

Output:

Using Global Variables In Function

We can use global variables across multiple functions of the same module.

Now, let’s see how to use the global variable inside a Python function.

• First, create a global variable x and initialize it to 20. The same global variable x is accessible to everyone, both inside of functions and outside.
• Now, create a function with a combination of local variables and global variables.
• Create a local variable y And initialize it to 30. A local variable is declared inside the function and is not accessible from outside it. The local variable’s scope is limited to that function only where it is declared.
• In the end, add a global variable x and local variable y to calculate the sum of two variables.

Example:

Output:

Global Variable and Local Variable with Same Name

Note: If you create a new local variable inside a function with the same name as a global variable, it will not override the value of a global variable. Instead, the new variable will be local and can only be used inside the function. The global variable with the same name will remain unchanged.

Example:

Output:

global Keyword in Python

The global keyword is used in the following two cases.

• To access and modify a global variable inside a function
• To create a new global variable inside a function

Modify a global variable inside a function

let’s see the below code.

Output:

Execute the above code to change the global variable x’s value. You’ll get an UnboundLocalError because Python treats x as a local variable, and x is also not defined inside my_func(). i.e, You cannot change or reassign value to a global variable inside a function just like this.

Use the global keyword to change the value of a global variable inside a function.

Example:

Output:

Create a global variable inside a function

in Python, the scope of variables created inside a function is limited to that function. We cannot access the local variables from outside of the function. Because the scope is local, those variables are not visible outside the function.

To overcome this limitation, we can use the global keyword to create a global variable inside a function. This global variable is accessible within and outside the function.

Example:

Output:

Rules of global keyword

Let us see the rules we need to follow to create and use a global keyword.

• If we create a variable inside a function, it is a local variable by default.
• If we create a variable outside the function, it turns into a global variable, and we don’t have to use the keyword global.
• We use the keyword global to create a global variable inside a function or to change a global variable already declared outside the function.
• Using the global keyword outside the function does not make any difference.

Global Variables Across Python Modules/Files

By default, the global variables are accessible across multiple functions of the same module. Now, we’ll see how to share global variables across the modules.

• First, create a special module config.py and create global variables in it.
• Now, import the config module in all application modules, then the module becomes available for a global name.

Let us understand it using an example.

In Python, to create a module, write Python code in the file, and save that file with the .py extension.

Example: Share global variables across Python modules.

config.py : The config module stores global variables of school and grade

Now, run the config.py file.

company.py : create a company.py file to import global variables and modify them. In the company.py file, we import the config.py module and modify the values of the name and address.

Now, run the company.py file.

Now, in the employee file, we import both config and company modules to test the values of global variables and whether they are changed.

Output:

As you can see in the output, we successfully accessed and modified the global variables across the files or modules.

globals() function in Python

In this section, we’ll see what the globals() do in Python.

We can also use the globals() function to access and modify the global variables. The globals() function returns the dictionary of the current global symbol table.

The global symbol table stores all information related to the program’s global scope and is accessed using the globals() method.

Function and variables are not part of any class, or functions are stored in a global symbol table.

Example: Modify the global variable using the globals() function.

Output:

Global variables in Nested Function

Now, Let’s see how to use a global variable in a nested function. Global variables can be used in a nested function using global or nonlocal keywords.

The difference between nonlocal and global is that global is used to change global variables, while nonlocal is used to change variables outside the function. Let us illustrate this with an example.

Example: Access global variables in nested functions using the global keyword

Output:

Did you find this page helpful? Let others know about it. Sharing helps me continue to create free Python resources.

About Vishal

Founder of PYnative.com I am a Python developer and I love to write articles to help developers. Follow me on Twitter. All the best for your future Python endeavors!

Related Tutorial Topics:

Python Exercises and Quizzes

Free coding exercises and quizzes cover Python basics, data structure, data analytics, and more.