比较一下，不使用nonlocal:

x = 0
def outer():
    x = 1
    def inner():
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 0

为此，使用非局部，其中inner()的x现在也是outer()的x:

x = 0
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 2
# global: 0

如果我们要使用global，它会将x绑定到正确的“global”值:

x = 0
def outer():
    x = 1
    def inner():
        global x
        x = 2
        print("inner:", x)
        
    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 2

它取源代码中“最接近”的引用点。 这被称为“词法范围”，是>40年来的标准。

Python的类成员实际上在一个名为__dict__的字典中，并且永远不会通过词法作用域到达。

如果你不指定nonlocal，而是指定x = 7，它将创建一个新的局部变量"x"。 如果你指定了nonlocal，它会找到“最接近”的“x”并赋值给它。 如果你指定了nonlocal并且没有“x”，它会给你一个错误消息。

关键字global对我来说总是很奇怪，因为它会很高兴地忽略所有其他的“x”，除了最外面的那个。

文件如下:

非局部语句导致所列出的标识符被引用 先前在最近的封闭范围内绑定的变量除外 全局变量。

例如，inner()中的非局部变量foo可以访问middle()中的非局部变量foo = 10，但不能访问outer()中的非局部变量foo = 5或outer()外的全局变量foo = 0，如下所示:

foo = 0 # <- ✖
def outer():
    foo = 5 # <- ✖
    def middle():
        foo = 10 # <- 〇
        def inner():
            nonlocal foo # Here
            foo += 1
            print(foo) # 11
        inner()
    middle()
outer()

比较一下，不使用nonlocal:

x = 0
def outer():
    x = 1
    def inner():
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 0

为此，使用非局部，其中inner()的x现在也是outer()的x:

x = 0
def outer():
    x = 1
    def inner():
        nonlocal x
        x = 2
        print("inner:", x)

    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 2
# global: 0

如果我们要使用global，它会将x绑定到正确的“global”值:

x = 0
def outer():
    x = 1
    def inner():
        global x
        x = 2
        print("inner:", x)
        
    inner()
    print("outer:", x)

outer()
print("global:", x)

# inner: 2
# outer: 1
# global: 2

引用自Python 3

非局部语句导致列出的标识符引用之前在最近的封闭范围内绑定的变量(不包括全局变量)。

如参考文献中所述，在多个嵌套函数的情况下，只有最近的封闭函数中的变量被修改:

def outer():
    def inner():
        def innermost():
            nonlocal x
            x = 3

        x = 2
        innermost()
        if x == 3: print('Inner x has been modified')

    x = 1
    inner()
    if x == 3: print('Outer x has been modified')

x = 0
outer()
if x == 3: print('Global x has been modified')

# Inner x has been modified

“最近的”变量可能在几层之外:

def outer():
    def inner():
        def innermost():
            nonlocal x
            x = 3

        innermost()

    x = 1
    inner()
    if x == 3: print('Outer x has been modified')

x = 0
outer()
if x == 3: print('Global x has been modified')

# Outer x has been modified

但它不能是一个全局变量:

def outer():
    def inner():
        def innermost():
            nonlocal x
            x = 3

        innermost()

    inner()

x = 0
outer()
if x == 3: print('Global x has been modified')

# SyntaxError: no binding for nonlocal 'x' found

在谷歌中搜索“python nonlocal”，可以找到提案PEP 3104，它完整地描述了语句背后的语法和推理。简而言之，它的工作方式与global语句完全相同，只是它用于引用对函数来说既不是全局变量也不是局部变量的变量。

下面是一个简单的例子，说明您可以使用它做什么。可以重写计数器生成器来使用它，使它看起来更像带有闭包的语言的习惯用法。

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

显然，你可以把它写成一个生成器，像这样:

def counter_generator():
    count = 0
    while True:
        count += 1
        yield count

但是，虽然这是完美的python习惯用法，但对于初学者来说，第一个版本似乎更明显一些。通过调用返回的函数正确使用生成器是一个常见的混淆点。第一个版本显式返回一个函数。