51

In the following Python code, I get an UnboundLocalError. As I understand it, local functions share the local variables of the containing function, but this hardly seems to be the case here. I recognise that a is an immutable value in this context, but that should not be a problem.

def outer():
    a = 0
    def inner():
        a += 1
    inner()
outer()

It would seem that the inner function has received copies of all the references in the parent function, as I do not get the UnboundLocalError exception if the value of a is wrapped in a mutable type.

Is someone able to clarify the behaviour here, and point me to the appropriate Python documentation on this?

Improve this question
1
  • 1
    The distinction isn't "mutable type vs immutable type" (Python types its values rather than its variables, after all), but "mutating a value vs assigning a value". Commented Sep 11, 2022 at 9:48

3 Answers 3

Reset to default
46

I believe you're correct in seeing this as a "mutability" problem. While the code you posted does throw an "UnboundLocalError", the following code does not:

def outer():
    a = 0
    def inner():
        print a
    inner()
outer()

Python doesn't allow you to reassign the value of a variable from an outer scope in an inner scope (unless you're using the keyword "global", which doesn't apply in this case).

Check out the bottom section of the "classes" documentation in this Python 2.6.2 documentation:

9.2. Python Scopes and Namespaces

[…] If a name is declared global, then all references and assignments go directly to the middle scope containing the module’s global names. Otherwise, all variables found outside of the innermost scope are read-only (an attempt to write to such a variable will simply create a new local variable in the innermost scope, leaving the identically named outer variable unchanged).

Your "UnboundLocalError" is because your function is actually declaring a new variable called "a" and then immediately trying to do a "+=" operation on it, but this fails because "a" does not have a value yet. (View the "a+=1" as "a = a+1" and you can see the problem if "a" is undefined).

In general, if you're going to want to modify "a", the way people usually get around it is to use a mutable type to pass "a" around (such as a list or a dictionary). You can modify "a" via the contents of the mutable type (as you probably noticed in your testing with this setup).

Hope that helps!

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Image
Yes I believe inner is receiving a copy of all the outer references. However on assignment to the immutable one's, the new value is only bound to the inner functions scope.
Image
I guess the only question I have now then is if locals() != the "innermost scope" as described in the documentation you linked to.
Image
BTW, Python3 addresses this by adding the nonlocal statement: docs.python.org/3.1/reference/…
26

You should specify your variable as nonlocal to preserve it's state in closure, so definition should be like this

def outer():
    a = 0
    def inner():
        nonlocal a
        a += 1
    inner()
Improve this answer

1 Comment

Image
Beware, however. I tried this in Python 2.7.6 and got a syntax error. According to this answer, stackoverflow.com/a/14264325/1286986, 'nonlocal' only works in Python 3.
11

Try binding the variable as an argument. 

def outer():
    a = 0
    def inner(a=a):
        a += 1

    inner()

outer()

I'll try and dig up the appropriate documents.

edit

Since you want the inner function to have a side effect on the outer scope, then you need to use a mutable datatype like a list. Integers and strings are immutable.

def outer():
    a = [0]
    def inner():
        a[0] += 1
    inner()
    print a[0]
outer()
Improve this answer

2 Comments

Image
I have found this suggestion under documentation from older versions of Python. There is still the issue that incrementing a will not affect the outer() a.
Image
If you want it to have a side effect, then you need to use a mutable type for a.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.