Question

I would like to know details about why this doesn’t work as expected:

def outer():
    mylist = []
    def inner():
        mylist += [1]

    inner()

outer()

Especially because mylist.__iadd__([1]) works fine.

Answer 1

The problem is that when you assign to a variable name inside a function, Python assumes you’re trying to create a new local variable that will mask a similarly-named variable in outer scope. Since += has to get the value of mylist before it can modify it, it complains, because the local version of mylist isn’t yet defined. MRAB’s answer gives a clear explanation of the semantics.

On the other hand, when you do mylist.__iadd__([1]), you aren’t assigning a new variable name inside the function. You’re just using a built-in method to modify an already-assigned variable name. As long as you don’t try to assign a new value to mylist, you won’t have a problem. For the same reason, the line mylist[0] = 5 would also work inside inner if the definition of mylist in outer were mylist = [1].

Note however that if you do try to assign a new value to mylist anywhere in the function, mylist.__iadd__([1]) will indeed fail:

>>> outer()
>>> def outer():
...     mylist = []
...     def inner():
...         mylist.__iadd__([1])
...         mylist = []
...     inner()
... 
>>> outer()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 6, in outer
  File "<stdin>", line 4, in inner
UnboundLocalError: local variable 'mylist' referenced before assignment

If you want to assign a new value to a variable from a containing scope, in 3.0+ you can use nonlocal, in just the way you’d use global to assign a new value to a variable in global scope. So instead of this:

>>> mylist = []
>>> def inner():
...     global mylist
...     mylist += [1]
... 
>>> inner()
>>> mylist
[1]

You do this:

def outer():
    mylist = []
    def inner():
        nonlocal mylist
        mylist += [1]
    inner()
    print(mylist)
outer()