How To Resolve UnboundLocalError On Local Variable When Reassigned After The First Use?

5/5 - (2 votes)

Summary: To resolve an UnboundLocalError when the local variable is reassigned after the first use, you can either use the global keyword or the nonlocal keyword. The global keyword allows you to modify the values of a global variable from within a function’s local scope while the nonlocal keyword provides similar functionality in case of nested functions.

UnboundLocalError In Python

Problem: Given a local variable. How to resolve an UnboundLocalError when the local variable is reassigned after the first use?


val = 100

def func():
    val = val + 100



Traceback (most recent call last):
  File "C:/Users/Shubham-PC/PycharmProjects/pythonProject1/", line 9, in <module>
  File "C:/Users/Shubham-PC/PycharmProjects/pythonProject1/", line 5, in func
    val = val + 100
UnboundLocalError: local variable 'val' referenced before assignment

Before we deal with the solutions to our problem, we must understand the the root cause behind UnboundLocalError.

Root Cause Of UnboundLocalErrors:

When a variable is assigned within a function, it is treated as a local variable by default in Python. If a local variable is referenced before a value has been assigned/bound to it, an UnboundLocalError is raised. In the above example when the variable 'val' is read by the Python interpreter inside the func() function, it assumes that 'val' is a local variable. However, it soon realizes that the local variable has been referenced before any value has been assigned to it within the function. Thus it throws an UnboundLocalError.

In other words, we can only access a global variable inside a function but cannot modify it from within the function (unless you force a global or nonlocal assignment using the global or nonlocal keywords).

Note: The parent class of all Python exceptions is BaseException. The following diagram represents the exception hierarchy of the UnboundLocalError.

UnboundLocalError Exception Hierarchy

Now that we know why and when an UnboundLocalError is raised, let us have a look at the probable solutions to overcome this error.

Method 1: Using The global Keyword

We can use the global keyword to access and modify a global variable from the local scope of a function. Any variable created outside a function is global by default while any variable created within the function is local by default. Thus, to modify a global variable from within the function and avoid an UnboundLocalError we can use the global keyword.

Let us have a look at the following code which simplifies the above concept:

val = 100
print("Value at First Usage: ", val)

def func():
    global val
    val = val + 100
    print("Output after Modification within func(): ", val)



Value at First Usage:  100
Output after Modification within func():  200

Method 2: Using nonlocal Keyword

The nonlocal keyword is used when we have a nested function. In such a situation local scope of a variable might not be defined, that is, the scope of a variable is neither local nor global.

Let us have a look at the following example to understand the usage of the nonlocal keyword to deal with our problem.

def func():
    val = 50
    print("Output of func:", val)

    def foo():
        nonlocal val
        val = val + 100
        print("Output of foo:", val)

    print("Output of func() after changes made to foo():", val)



Output of func: 50
Output of foo: 150
Output of func() after changes made to foo(): 150

In the above program, the nonlocal keyword is used with the variable val inside the nested function foo() to create a nonlocal variable. If the value of the nonlocal variable changes, the changes are reflected in the local variable as well.

Disclaimer: the nonlocal keyword works only in Python 3 and above.

Method 3: Using A Mutable Object

Since nonlocal does not work in versions of Python before Python 3, you can use a mutable object like a python dictionary, to store the values if you do not want to create a global variable.

Let us have a look at the following program to understand the usage of a mutable object in order to overcome the UnboundLocalError.

variables = {  # creating a mutable object/dictionary
    'val': 100
print('Output before Modification of val: ', variables['val'])

def func():
    variables['val'] += 50
    print('Output after Modification of val: ', variables['val'])

Output before Modification of val:  100
Output after Modification of val:  150

Method 4: Passing Parameters To The Function

This is the traditional way of solving our problem. Instead of using a global variable, we can pass parameters to the defined function to avoid an UnboundLocalError. Let us have a look at the following code to see how this can be done:

val = 100
print("Value of val at first use: ", val)

def func(v):
    v = v + 100
    print("Output of val after modification:", v)



Value of val at first use:  100
Output of val after modification: 200

Global Keyword vs Nonlocal Keyword

Before concluding this article, let us have a look at the key differences between a global and nonlocal variable/keywords.

  1. Unlike the global keyword, the nonlocal keyword works only in Python 3 and above.
  2. The global keyword can be used with pre-existing global variables or new variables whereas the nonlocal keyword must be defined with a pre-existing variable.


From the above discussion we learned that to deal with UnboundLocalError in our code we can use one of the following methods:

  1. Use the global keyword.
  2. Use the nonlocal keyword in case of nested functions.
  3. Use a mutable object.
  4. Pass parameters to a function.

I hope that you found this article helpful and after reading it you can deal with UnboundLocalError with ease. Please stay tuned for more interesting articles.

Where to Go From Here?

Enough theory. Letโ€™s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. Thatโ€™s how you polish the skills you really need in practice. After all, whatโ€™s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

๐Ÿš€ If your answer is YES!, consider becoming a Python freelance developer! Itโ€™s the best way of approaching the task of improving your Python skillsโ€”even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar โ€œHow to Build Your High-Income Skill Pythonโ€ and learn how I grew my coding business online and how you can, tooโ€”from the comfort of your own home.

Join the free webinar now!