Global and Local Variables

Overview

In programming, variables are used to store data values that can be referenced and manipulated during program execution. Variables can be classified as global or local based on their scope, or the part of the program where they can be accessed. Understanding the differences, benefits, and drawbacks of global and local variables is crucial for writing efficient and error-free code.

What are Variables?

• Variables are named storage locations in memory used to hold data.
• Scope: Determines where a variable can be accessed within a program.

Global Variables

• Definition: Variables declared outside of any function, class, or block.
• Scope: Accessible from any part of the program, including within functions.
• Lifetime: Exist for the entire duration of the program.

global_var = 10  # Global variable

def display():
    print(global_var)  # Accessible inside the function

display()

Local Variables

• Definition: Variables declared within a function, class, or block.
• Scope: Accessible only within the block or function where they are defined.
• Lifetime: Exists only while the function or block is executing.

def calculate():
    local_var = 5  # Local variable
    print(local_var)

calculate()
# print(local_var)  # This will cause an error as local_var is not accessible here

Differences Between Global and Local Variables

Benefits and Drawbacks of Global Variables

Benefits of Global Variables

1. Easy Sharing of Data: Useful for data that needs to be accessed and modified by multiple functions.
2. Persistent Data: Remain in memory throughout the program, useful for maintaining state.

Drawbacks of Global Variables

1. Increased Risk of Errors: Accidental modification by any function can lead to unintended behaviour.
2. Harder to Debug and Maintain: Since they can be modified anywhere, it's harder to track changes and bugs.
3. Increased Memory Usage: Occupy memory for the program's entire duration, even if not always needed.

Benefits and Drawbacks of Local Variables

Benefits of Local Variables

1. Reduced Risk of Errors: Changes to local variables are confined to a specific function, minimising unintended interference.
2. Efficient Memory Usage: Memory is allocated and freed dynamically, reducing overall memory consumption.
3. Easier Debugging and Testing: Since their scope is limited, it's easier to isolate and resolve issues.

Drawbacks of Local Variables

1. Limited Access: Cannot be accessed outside their defining function or block, requiring additional mechanisms to share data if needed.
2. Reinitialisation Overhead: This must be reinitialised each time the function is called, which could impact performance for frequently called functions.

Recognising and Converting Variables

Recognising Global Variables

• Declared outside any function.
• Used or modified directly in multiple functions.

Recognising Local Variables

• Declared inside a function or block.
• Only accessible within that function or block.

Converting Global to Local Variables

• Identify where the global variable is used.
• Pass it as a parameter to functions that need it.

# Using a global variable
score = 0  # Global variable

def update_score():
    global score
    score += 10

# Converting to local variable
def update_score(local_score):
    local_score += 10
    return local_score

score = 0  # Initial value
score = update_score(score)

Converting Local to Global Variables

• Identify the variable's use across multiple functions.
• Declare it outside the functions and use the global keyword to modify it inside the function.

def set_global_var():
    global global_var
    global_var = 10

Note Summary

x = 10  # Global

def func():
    x = 5  # Local variable shadows the global x
    print(x)  # Prints 5
func()
print(x)  # Prints 10

:::