Skip to main content

Python global Keyword

What is the global keyword?​

The global keyword is used to create or update a global variable from a nonglobal scope (such as within a function or class).

This means that the global keyword allows the variable to be modified outside the current scope. It is used to create a global variable and make changes to the variable in a local context.

Syntax​

The syntax of the global keyword is as follows:

global var1,var2,…

where var1, var2, ... are identifiers for variable names.

Rules of global keyword​

The rules for the global keyword in Python are:

  • A variable created within a function is local by default.
  • A variable created outside a function is global by default. It is not necessary to use the global keyword.
  • The global keyword is used to read and write a global variable within a function.
  • Using the global keyword outside of a function has no effect.

Examples​

Modifying Global Variable Inside a Function​

note

The global keyword must be used to modify a global variable inside a function.

A variable declared outside all functions has a global scope. This means that it is accessible throughout the file and also within any file that imports it.

Consider the following (wrong) example:

my_var = 1 # global variable
    
def increment():
    # change value of global_variable
    my_var = my_var + 1
    print(my_var)

increment()

The program will show an error:

UnboundLocalError: local variable 'my_var' referenced before assignment
note

This is because you can only access the global variable, but you can't change it within the function.

Note that in the above example the global keyword isn't used to declare the variable as global within the scope of the function.

Therefore, the correct way to modify a global variable within a function is as follows:

my_var = 1 # global variable
    
def increment():
    global my_var       # declare my_var global
    print(my_var)
    my_var = my_var + 1 # change value of my_var
    print(my_var)

increment()
print(my_var)

Output

1
2
2

Create Global Variable Inside a Function​

When you declare a variable global, it is added to global scope, if not already present.

For example, declare x global inside a function and access it outside the function:

def my_function():
    global x    # x is global
    x = 123

my_function()
print(x)        # 123

Output

123

Global Variables in Nested Functions​

def outer_function():
    x = 10

    def inner_function():
        global x
        x = 20
    
    print(f"Before calling inner_function: {x}")
    inner_function()
    print(f"After calling inner_function: {x}")

outer_function()
print(f"x in main: {x}")

Output

Before calling inner_function: 10
After calling inner_function: 10
x in main:  20

If changes are made within the inner_function() function, the changes appear outside the local scope (thus also in outer_function().

This is because the global keyword is used in x to create a global variable within the inner_function() function.

Global Variables Across Python Modules​

In Python, a single module, called for example config.py, can be created to contain global variables and share information among Python modules in the same program.

Let's see how with an example.

Create a config.py file that stores global variables:

config.py
my_number = 0
my_string = "a string"

Create a updater.py file to change global variables

updater.py
import config

config.my_number = 123
config.my_string = "another string"

Create a main.py file print the variables

main.py
import config
import update

print(config.my_number)
print(config.my_string)

Output

123
another string

Table of Contents