As a Python developer, it’s essential to understand how to handle variable scope and avoid the common “local variable referenced before assignment” error.

This error occurs when you attempt to use a variable before it’s been assigned a value. Here’s what the error looks like:

UnboundLocalError: local variable 'value' referenced before assignment

In this guide, we’ll explore the reasons behind this error and how to fix it.

Understanding and Resolving the “local variable referenced before assignment” Error

Consider the following example that triggers this error:

value = 1

def increment():
    value = value + 1
    print(value)

increment()

Running this code will produce the following error:

UnboundLocalError: local variable 'value' referenced before assignment

The problem arises because, inside the increment() function, we are defining a local variable named value and attempting to use it before assigning it a value. Instead, we should be using the global value variable defined in the first line.

To resolve this issue, we can use the global keyword to refer to the global variable instead of creating a new local variable. The global keyword allows us to access and modify a variable that’s defined outside the function.

Here’s how we can use the global keyword to fix the issue:

value = 1

def increment():
    global value
    value = value + 1
    print(value)

increment()

By adding the global value line inside the increment() function, we’re explicitly telling Python that we want to use the global variable value instead of creating a new local variable. Running the modified code will now produce the expected output:

2

Other Solutions for the “local variable referenced before assignment” Error

In addition to using the global keyword, there are other ways to fix the error depending on the specific use case.

1. Using function arguments and return values

Instead of using a global variable, you can pass the variable as an argument to the function and return the modified value:

value = 1

def increment(value):
    value = value + 1
    return value

value = increment(value)
print(value)

This approach avoids using global variables and makes the function more flexible and reusable.

2. Using nonlocal keyword in nested functions

When working with nested functions, you can use the nonlocal keyword to indicate that a variable should be accessed from the nearest enclosing scope that is not global:

def outer():
    value = 1

    def inner():
        nonlocal value
        value = value + 1
        print(value)

    inner()

outer()

The nonlocal keyword allows the inner() function to access and modify the value variable from the outer() function, without creating a new local variable or using a global variable.

Conclusion

The “local variable referenced before assignment” error occurs when you try to use a variable before assigning it a value.

To fix this error, you can use the global keyword to refer to a global variable, pass the variable as an argument to the function and return the modified value, or use the nonlocal keyword in nested functions to access variables from the nearest enclosing scope.

By understanding the underlying reasons for this error and how to fix it, you can write more efficient and error-free Python code.

Further Reading