Global and Local Variables

What Will You Learn
In this section, you’ll learn how Python handles variable scope inside and outside of functions. You'll explore the difference between global and local variables, how to declare them properly, and when to use the global keyword. Understanding scope is crucial for avoiding bugs, writing maintainable code, and controlling how data flows in your Python programs.

Understanding the difference between global and local variables is essential for writing correct and maintainable code. As a beginner, you will frequently define and access variables inside functions. However, improper use of variable scope can lead to bugs that are hard to track. Knowing when a variable is accessible and when it is not helps you control the behavior of your program. It also makes your code more predictable and prevents accidental changes to important data. Global variables are useful for sharing data across multiple functions, but overusing them can make code harder to debug. Local variables, on the other hand, provide better encapsulation and reduce side effects. 

What Are Global and Local Variables in Python?

In Python, variables are defined within a certain scope. A local variable is declared inside a function and only exists during that function’s execution. A global variable is declared outside all functions and can be accessed anywhere in the code.

Example 1: Local variable

    def greet():
        message = "Hello"
        print(message)

    greet()

• message is a local variable, visible only within greet(). Trying to access it outside will cause an error.

Example 2: Global variable

    count = 0

    def increment():
        global count
        count += 1

    increment()
    print(count)

• count is a global variable, defined outside the function. We use the global keyword to modify it inside increment().

Example 3: Name conflict

    x = 5

    def example():
        x = 10
        print(x)

    example()
    print(x)

• The function defines its own local x, which does not affect the global x. Output will be 10 and then 5.

By default, Python treats any variable assigned in a function as local, unless you explicitly declare it as global using the global keyword.

What Are the Differences Between Global and Local Variables in Python?

Global and local variables differ primarily in their scope and lifetime. A global variable exists throughout the entire execution of a program, while a local one is created when a function runs and disappears after it returns. Global variables can be accessed from anywhere in the file, but local variables are accessible only inside the function where they are defined. Changing a global variable from within a function requires the global keyword. Without it, any assignment creates a new local variable with the same name. Overusing global variables leads to tightly coupled and hard-to-test code. Local variables promote encapsulation and safer program logic.

What Are the Best Practices for Managing Local and Global Variables in Python?

Proper variable scope management improves code quality, readability, and reliability. Beginners often misuse global variables, which leads to unexpected behavior and maintenance difficulties. While globals are not inherently bad, they should be used sparingly and intentionally. Prefer local variables for all temporary calculations and function-specific logic. If you need to share data across multiple functions, consider returning values or using function parameters instead. Maintain a clear structure and avoid naming conflicts.

Best practices include:

• Minimize the use of global variables. Use them only when data must persist across many parts of your codebase.
• Use function parameters to pass data. Instead of reading or modifying global variables, pass values explicitly.
• Return results from functions. Return data rather than setting global state inside the function.
• Use clear and distinct variable names. Avoid reusing the same names in global and local scope.
• Avoid mutable global data structures. Lists and dictionaries as globals can be modified unintentionally.
• Encapsulate logic in functions or classes. This keeps your code modular and protects variable scope.
• Use global keyword only when absolutely necessary. It should signal a deliberate decision to alter shared state.

Common Beginner Mistakes

Mistake 1: Trying to modify a global variable without the global keyword

Beginners often assume that assigning a value to a global variable inside a function will update it. However, Python treats such assignment as the creation of a new local variable unless explicitly marked as global. This causes unexpected results or bugs when the global variable remains unchanged.

Incorrect:

    count = 0

    def increment():
        count += 1  # UnboundLocalError

    increment()

Correct:

    count = 0

    def increment():
        global count
        count += 1

    increment()

Mistake 2: Accessing a local variable outside its function

A variable created inside a function does not exist outside of it. Beginners sometimes try to use such variables globally, which results in a NameError.

Incorrect:

    def calculate():
        result = 10 + 5

    print(result)  # NameError

Correct:

    def calculate():
        result = 10 + 5
        return result

    print(calculate())

Mistake 3: Naming conflicts between local and global variables

Using the same variable name in both global and local scopes can lead to confusion and errors. The local version will shadow the global one, which may not be the intended behavior.

Incorrect:

    value = 100

    def print_value():
        value = 50
        print(value)

    print_value()
    print(value)  # Unexpected difference

Correct:

    global_value = 100

    def print_value():
        local_value = 50
        print(local_value)
    
    print_value()
    print(global_value)

Mistake 4: Relying too much on global variables for function logic

Putting all shared data in global variables can make functions dependent and hard to reuse. A better approach is to pass parameters and return values.

Inefficient:

    name = "Alice"

    def greet():
        print(f"Hello, {name}")

Better:

    def greet(name):
        print(f"Hello, {name}")

    greet("Alice")

Mistake 5: Modifying mutable global objects without realizing side effects

Modifying lists or dictionaries declared globally can lead to side effects across your program, especially in larger codebases.

Risky:

    data = []

    def add_item(item):
        data.append(item)  # This modifies the global list

Better:

    def add_item(data, item):
        data.append(item)
        return data

Frequently Asked Questions (FAQ)

    x = 10

    def change_x():
        global x
        x = 20

    name = "Alice"

    def greet():
        print(f"Hello, {name}")  # Access is allowed
        
    greet()

    count = 10

    def update():
        print(count)  # Error: count is considered local but used before assignment
        count = 20

    total = 0

    def add():
        global total
        total += 1

    x = 5

    def show():
        x = 10
        print(x)
        
    show()       # prints 10 (local)
    print(x)     # prints 5 (global)

        counter = 0

        def inc():
            global counter
            counter += 1
        
        def dec():
            global counter
            counter -= 1
        
        inc()
        dec()
        print(counter)

        x = 50

        def test():
            x += 1  # Error: local variable referenced before assignment
        
        test()

    def test():
        global x
        x += 1