a = 0    #1. global variable with respect to every function in program

def f():
    a = 0          #2. nonlocal with respect to function g
    def g():
        nonlocal a
        a=a+1
        print("The value of 'a' using nonlocal is ", a)
    def h():
        global a               #3. using global variable
        a=a+5
        print("The value of a using global is ", a)
    def i():
        a = 0              #4. variable separated from all others
        print("The value of 'a' inside a function is ", a)

    g()
    h()
    i()
print("The value of 'a' global before any function", a)
f()
print("The value of 'a' global after using function f ", a)

help('nonlocal') The nonlocal statement nonlocal_stmt ::= "nonlocal" identifier ("," identifier)* The nonlocal statement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope. This is important because the default behavior for binding is to search the local namespace first. The statement allows encapsulated code to rebind variables outside of the local scope besides the global (module) scope. Names listed in a nonlocal statement, unlike to those listed in a global statement, must refer to pre-existing bindings in an enclosing scope (the scope in which a new binding should be created cannot be determined unambiguously). Names listed in a nonlocal statement must not collide with pre- existing bindings in the local scope. See also: PEP 3104 - Access to Names in Outer Scopes The specification for the nonlocal statement. Related help topics: global, NAMESPACES

来源:Python语言参考

我个人对“非局部”语句的理解(请原谅我对Python和编程并不熟悉)是，“非局部”是在迭代函数中使用全局功能的一种方式，而不是在代码本身中使用。一个函数之间的全局语句。

比较一下，不使用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

使用“非局部”内部函数(即嵌套内部函数)可以获得外部父函数的特定变量的读和写权限。而nonlocal只能在内部函数中使用 例如:

a = 10
def Outer(msg):
    a = 20
    b = 30
    def Inner():
        c = 50
        d = 60
        print("MU LCL =",locals())
        nonlocal a
        a = 100
        ans = a+c
        print("Hello from Inner",ans)       
        print("value of a Inner : ",a)
    Inner()
    print("value of a Outer : ",a)

res = Outer("Hello World")
print(res)
print("value of a Global : ",a)

在谷歌中搜索“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习惯用法，但对于初学者来说，第一个版本似乎更明显一些。通过调用返回的函数正确使用生成器是一个常见的混淆点。第一个版本显式返回一个函数。