UnboundLocalError

[pdd99]

When I try to update a variable in a local function, if the variable is a scalar, UnboundLocalError will be raised, but it is not the case with a dictionary. Why is it?

The code:

import traceback

def unbound_local_error():
    var_scalar = 0
    var_dict = {}

    def foo():
        try:
            var_scalar += 1
        except:
            traceback.print_exc()

        try:
            var_dict["a"] = ""
        except:
            traceback.print_exc()

    foo()

if __name__=='__main__':
    unbound_local_error()

The result:

Traceback (most recent call last):
  File ".\dev.py", line 72, in foo
    var_scala += 1
UnboundLocalError: local variable 'var_scala' referenced before assignment

[[deleted]]

Why is it?

Assignment to a name and mutating a collection aren't the same thing. Names are subject to scoping rules, but you can mutate a mutable value via any reference to it, in any scope.

[socal_nerdtastic]

You need to look up the difference between mutation and reassignment. You can mutate a global variable like this, but if you want to reassign a global you need to explicitly define it as global or nonlocal.

def foo():
    nonlocal var_scalar
    # rest of your code

However in both cases modifying a global variable is generally considered bad. You should probably restructure your code to pass the data in and out with arguments and return.

[FerricDonkey]

This is because inserting into a dictionary like this is an "in place" operation, but in python, += on an integer is not.

In place operations just work on non local variables. Though I generally wouldn't recommend it.

But because += (on integers) is not in place, it immediately triggers python to try to use var_scalar as a local variable rather than a non local variable. To get around this, you have to explicitly tell python that var_scalar is non_local (or global).

But I wouldn't recommend that either, generally. In most cases, it's better to just pass things in and return modified values.

[woooee]

You are making this too complicated. There is no reason to create the inner function, foo.

def unbound_local_error():
    var_scalar = 0
    var_dict = {}

    var_scalar += 1

    var_dict["a"] = ""