Global And Local Variables

Global Variables

In Python, a global variable is a variable that is accessible throughout the entire program. It is defined outside of any function or class. This means its scope is the entire file, and any function can access and modify its value. You can use the global keyword inside a function to modify a global variable.

Example of a Global Variable:

Python

x = 10  # This is a global variable

def my_function():
    print(x)  # This function can access the global variable 'x'

my_function()  # Output: 10
print(x)       # Output: 10

---

Local Variables

A local variable is a variable defined inside a function. It is only accessible within the scope of that specific function. Once the function finishes execution, the local variable is destroyed, and its value cannot be accessed from outside the function.

Example of a Local Variable:

Python

def my_function():
    y = 20  # This is a local variable
    print(y)

my_function()  # Output: 20
# print(y)     # This will cause an error because 'y' is a local variable and is not defined outside the function

Key Differences

• Scope: Global variables have a global scope (accessible everywhere), while local variables have a local scope (accessible only within the function they are defined in).
• Lifetime: Global variables exist as long as the program is running. Local variables are created when the function is called and destroyed when the function completes.
• Modification: To modify a global variable inside a function, you must use the global keyword. You do not need a special keyword to modify a local variable within its own function.

Python

# A global variable for a game score
score = 0

def add_points(points):
    # The 'global' keyword is needed to modify the global variable
    global score
    score += points

add_points(10)
print(score)  # Output: 10

Python

# A global variable
count = 0

def increment():
    # This creates a new local variable named 'count', it does NOT change the global one.
    count = 100
    print(f"Inside function, local count is: {count}")

def correct_increment():
    # This modifies the global 'count'
    global count
    count = 100
    print(f"Inside function, global count is: {count}")

increment()
print(f"Outside function, global count is: {count}") # Output: 0

correct_increment()
print(f"Outside function, global count is: {count}") # Output: 100

The globals() Function

The globals() function in Python returns a dictionary representing the current global symbol table. This table contains all the global variables, functions, and classes defined in the current module. You can use it to inspect or even modify global variables.

• How it works: When you call globals(), it gives you a dictionary where the keys are the names of the global variables and the values are their corresponding objects.

Python

x = 10
y = "hello"

def my_func():
    pass

global_vars = globals()
print(global_vars['x'])      # Output: 10
print('y' in global_vars)    # Output: True

You can also use it to add or change global variables, but this is generally not recommended as it can make your code hard to follow.

---

The locals() Function

The locals() function returns a dictionary representing the current local symbol table. This table contains all the local variables in the current scope.

• How it works: When called inside a function, locals() returns a dictionary of the variables defined within that function. When called at the top level of a module (outside any function), it returns the same dictionary as globals().

Python

def my_function():
    a = 1
    b = "world"
    local_vars = locals()
    print(local_vars['a'])      # Output: 1
    print('b' in local_vars)    # Output: True

my_function()

The dictionary returned by locals() should be treated as read-only. Modifying it might not affect the local variables themselves in some Python implementations, so it’s best to only use it for inspection.