python 3.x 中的闭包和变量 scope 问题导致我感到困惑

Question

I am using Python 3.7.0 and I am doing some experiments in order to comprehend the subtleties of variable scopes but I still don't understand this behaviour.

When I execute this code:

def f():
    x=0
    def g():y=x+1;x=y
    return g
f()()

I get UnboundLocalError: local variable 'x' referenced before assignment

However when I execute this one:

def f():
   x=0
   def g():y=x+1
   return g
f()()

It works fine. And even this one:

def f():
   x=0
   def g():x=1
   return g
f()()

It also works fine. So I am confused. It seems to me that if assigning the value 1 to the nonlocal variable x in the g function works fine alone and on the other hand if assigning an expression containing x to a local variable y in the function g works also fine then the instructions y=x+1 and x=y should both work. I don't understand what is causing the error. I feel I am missing something fundamental in my understanding of Python's behaviour.

Answer 1

I'll take an ill-advised crack at this. In the following code:

def f():
    x = 0  # assignment makes this x local to f()

    def g():
        y = x + 1
        x = y  # assignment makes this x local to g()

    return g

f()()

The assignment of x inside g() forces it to be a variable local to g() . So the first line causes the error as you accessing the value of an unassigned local. I believe this "assignment makes it local" logic doesn't follow the flow of your program -- the function is viewed as whole to make this determination and then the code is looked at line by line.

You can access any variable in scope from a function, but you can only set locals. Unless you've declared the variable you're assigning as global or nonlocal :

def f():
    x = 0  # assignment makes this x local to f()

    def g():
        nonlocal x

        y = x + 1
        x = y  # x is declared to come from a nonlocal scope

    return g

f()()

In your second example, it's not an issue as you're only looking at the value of x , not setting it, so it can come from any appropriate scope:

def f():
    x = 0  # assignment makes this x local to f()

    def g():
        y = x + 1  # x comes from an outer scope

    return g

f()()

Finally, your third example is the same as the first without the unssigned local variable usage error:

def f():
    x = 0  # assignment makes this x local to f()

    def g():
        x = 1  # assignment makes this x local to g()

    return g

f()()

It seems to me that if assigning the value 1 to the nonlocal variable x in the g function works fine alone

How did you determine that the reassignment of x in f() worked fine?