# Global & Local Variables ## Global Variables ### What is a global variable? - A global variable is declared at the **outermost scope** of a program - Declared **outside** any functions, procedures, or other code blocks - Global variables possess **global scope** - accessible and modifiable from anywhere in the program - Remain in memory for the **entire duration** of program execution

A global variable is declared at the top level of a program and can be accessed by all parts of the code

### Python example In this Python example, the variable `globalValue` (holding the value 25) is declared **outside** the function `displayValue`. This placement means the function, along with all other parts of the program, can access and modify this global variable. ```python globalValue = 25 # Declaring a global variable def displayValue(): global globalValue # Accessing the global variable within a function print("The value stored in the variable is:", globalValue) displayValue() # Calling the function ``` ### Usage & need for global variables - **Cross-module data sharing**: Global variables enable data sharing across different sections of a program, facilitating data transfer between modules without requiring parameter passing - **Persistent data storage**: Global variables maintain their values throughout program execution, making them ideal for storing data that must persist across multiple function calls - **Configuration constants**: Global variables can store configuration settings or constants relevant throughout the entire program ### Benefits and drawbacks | Benefits | Drawbacks | |----------|-----------| | Global variables require declaration only once | Global variables occupy memory continuously while the program runs, potentially consuming significant resources | | No need for repeated parameter passing between different code modules | Programs become harder to maintain because tracking where variables are modified becomes difficult | | | Testing individual code blocks becomes challenging since the entire program must run to establish global variables | ## Local Variables ### What is a local variable? - A local variable is declared **within a specific scope** - inside a function or code block - Local variables are accessible **only within** the block where they're defined - Their **lifetime is limited** to the execution of that particular block - Once block execution completes, the local variable is **destroyed** and its memory released

A local variable exists only within the function or block where it is declared and cannot be accessed from outside

### Python example In this Python code, the variable `localValue` (assigned the value 25) is declared **inside** the function `displayValue`. This means **only** this function can access and modify the local variable. Other parts of the program **cannot** access it. ```python def displayValue(): localValue = 25 # Declaring a local variable within the function print("The value of the local variable is:", localValue) displayValue() # Calling the function ``` ### Benefits and drawbacks | Benefits | Drawbacks | |----------|-----------| | Local variables provide **data encapsulation** within a specific function or block, ensuring data hiding and preventing unintended external access | Repeatedly creating and destroying local variables within loops or recursive functions can create unnecessary **memory overhead** | | Local variables allow using the **same variable name** across different functions or blocks without conflicts, since each local variable is restricted to its own scope | Excessive local variable use within deeply nested blocks can cause **code clutter** and reduce readability | | Local variables have **limited lifetime** - their memory is automatically reclaimed when the code block finishes, making them memory efficient | | ## Converting Between Global and Local Variables ### Global variable approach In the Python code below, a global variable named `global_message` is declared and set to "Hello" Two functions are created: `add_greeting` and `add_recipient` The `add_greeting` function appends the string ", welcome!"to `global_message` The `add_recipient` function accepts a string `recipient` as a parameter and appends it to `global_message` `add_greeting` is called and prints `global_message`, resulting in "Hello, welcome!" Subsequently, `add_recipient` is called with the argument "Sarah" and prints `global_message` again, resulting in "Hello, welcome! Sarah" ```python # Global variable global_message = "Hello" def add_greeting(): global global_message global_message += ", welcome!" def add_recipient(recipient): global global_message global_message += " " + recipient # Call the functions add_greeting() print(global_message) # Outputs: Hello, welcome! add_recipient("Sarah") print(global_message) # Outputs: Hello, welcome! Sarah ```

Global variables can be modified anywhere in the program, making debugging more difficult

### Local variable approach In this revised Python code, a local variable named `local_message` is declared and set to "Hello" Two functions are created: `add_greeting` and `add_recipient` The `add_greeting` function accepts a string `msg` as a parameter, appends the string ", welcome!" to it and returns the modified string The `add_recipient` function accepts two parameters: a string `msg` and a string `recipient`. It appends `recipient` to `msg` and returns the modified string `add_greeting` is called with `local_message` as the parameter and assigns the result back to `local_message`. `local_message` is printed, resulting in "Hello, welcome!" `add_recipient` is called with `local_message` and "Sarah" as parameters and assigns the result back to `local_message`. `local_message` is printed again, resulting in "Hello, welcome! Sarah" ```python def add_greeting(msg): msg += ", welcome!" return msg def add_recipient(msg, recipient): msg += " " + recipient return msg # Initialize a local variable local_message = "Hello" # Call the functions local_message = add_greeting(local_message) print(local_message) # Outputs: Hello, welcome! local_message = add_recipient(local_message, "Sarah") print(local_message) # Outputs: Hello, welcome! Sarah ```

Using local variables and return values provides better control over data flow and makes code easier to test

### Key differences in approach #### Global variable method: - Variables declared **once** at program start - Functions **directly modify** the global variable - **No return statements** needed - Changes are **immediately visible** everywhere - Harder to track which function changed the value #### Local variable method: - Variables passed **as parameters** - Functions work with **copies** of the data - Modified values must be **returned** - Changes must be **explicitly assigned** back - Clear **data flow** through parameters and returns - Easier to test and debug individual functions ### When to use each approach **Use global variables when:** - The data truly needs to be accessed throughout the entire program - You have configuration settings that remain constant - Performance is critical and you want to avoid parameter passing overhead **Use local variables when:** - Data is only relevant to specific functions - You want to make code more modular and testable - You need to prevent accidental data modification - You're writing functions that might be reused in different contexts

As a general rule, prefer local variables with parameter passing over global variables for more maintainable code