Difference Between Local and Global Variables in Python

What is a Global Variable?

A global variable is a variable defined outside any function or block and hence available throughout the program. Such variables can be accessed by any function if declared global inside that function.

Example of a Global Variable

# Global variable
greeting = "Hello, World!"

def print_greeting():
    print(greeting)  # Accessing global variable

def modify_greeting():
    global greeting
    greeting = "Hello, Python!"  # Modifying global variable

print_greeting()
modify_greeting()
print_greeting()

You can also try this code with Online Python Compiler

Run Code

Output:

Hello, World!
Hello, Python!
Hello, Python!

Here, the variable greeting is a global variable accessible and modifiable by both functions.

Advantages of Global Variables

1. Wide Scope: Can be accessed and modified by any part of the program.
    
2. Convenience: Useful for sharing data between multiple functions.
    
3. Fewer Parameters: Reduces the need for passing multiple parameters between functions.

Disadvantages of Global Variables

1. Risk of Unintended Modifications: Since global variables can be accessed from anywhere, there’s a higher chance of accidental changes.
    
2. Harder Debugging: In large programs, it becomes difficult to track changes in global variables.
    
3. Memory Usage: Global variables consume memory throughout the program’s runtime.

Examples to Understand Differences Between Local Variable Vs Global Variable

Let's take a simple example to understand the difference between local & global variables in Python.

def my_function():
    x = 10  # local variable
    print("Inside the function, x =", x)
x = 20  # global variable
my_function()
print("Outside the function, x =", x)

You can also try this code with Online Python Compiler

Run Code

In this code, we define a function called `my_function()`. Inside the function, we declare a local variable `x` & assign it the value of 10. We then print the value of `x` within the function.

Outside the function, we declare a global variable `x` & assign it the value of 20. We call `my_function()` & then print the value of `x` outside the function.

The output of this code will be:

Inside the function, x = 10
Outside the function, x = 20

As you can see, the local variable `x` inside `my_function()` is separate from the global variable `x` outside the function. Changes made to the local variable do not affect the global variable, & vice versa.

Now, let's modify the code slightly to see what happens when we try to access a global variable inside a function:

def my_function():
    print("Inside the function, x =", x)


x = 20  # global variable
my_function()
print("Outside the function, x =", x)

You can also try this code with Online Python Compiler

Run Code

In this case, we are trying to access the global variable `x` inside `my_function()` without declaring it as a local variable. The output will be:

Inside the function, x = 20
Outside the function, x = 20

The function is able to access the global variable `x` directly since it is not shadowed by a local variable with the same name.

Key Differences Between Local and Global Variables

Which One is More Useful?

The choice between using local or global variables depends on the specific needs of your program. Let’s discuss some of the guidelines to help you decide:

1. Use local variables when:
   • The variable is only needed within a single function.
      
   • You want to avoid unintended modifications to the variable from other parts of the code.
      
   • You need to create variables with the same name in different functions without interference.
      
2. Use global variables when:
   • The variable needs to be accessed & modified by multiple functions.
      
   • You want to share data across different parts of your program.
      
   • The variable represents a constant value that remains unchanged throughout the program.
      

In general, it is considered good programming practice to use local variables whenever possible. This promotes encapsulation, which makes your code more modular and reduces the risk of unintended side effects. Global variables should be used sparingly & only when necessary.
 

Example

# Global variable
counter = 0
def increment():
    global counter
    counter += 1  # Modifying global variable
    print("Counter:", counter)

def local_example():
    local_var = 10  # Local variable
    print("Local variable value:", local_var)
increment()
local_example()
increment()

You can also try this code with Online Python Compiler

Run Code

Output:

Counter: 1
Local variable value: 10
Counter: 2

In this example, the global variable counter is used to keep track of a count, while local_var is used for a specific task within the local_example function.

Frequently Asked Questions

What is the main difference between local and global variables in Python?

Local variables are declared within a function and are only accessible within that specific function. In contrast, global variables are defined outside any function and are accessible across the entire program.

How can you modify a global variable inside a function in Python?

To change the value of a global variable within a function, you must declare it using the global keyword before assigning a new value.

Why should we minimize the use of global variables in Python?

Using global variables excessively can cause unpredictable behavior and make debugging more challenging since their values can be altered from anywhere in the code. This increases the likelihood of errors and decreases the code's maintainability.

Conclusion

Understanding the difference between local and global variables is essential for writing efficient and organized Python programs. Local variables are great for temporary data within a function, while global variables allow for data sharing across the entire program. By knowing when and how to use each type, you can improve the readability, maintainability, and performance of your code.