“nonlocal” 是什么意思？ 在 Python 3 中做什么？

Question

nonlocal 在 Python 3.x 中做什么？

---

_{要关闭OP需要nonlocal并且没有意识到的调试问题，请使用是否可以修改python 中的变量位于外部范围，但不是全局范围？ 相反。}

_{尽管 Python 2 是 自 2020 年 1 月 1 日起正式不再支持，如果由于某种原因您被迫维护 Python 2.x 代码库并且需要与 nonlocal 等效的代码库code>，请参阅Python 2.x 中的非本地关键字。}

Answer 1

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

对此，使用 nonlocal，其中 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 绑定到正确的“全局”值：

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

Answer 2

简而言之，它允许您为外部（但非全局）范围内的变量赋值。 请参阅 PEP 3104 了解所有详细信息。

Answer 3

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

Answer 4

它采用与源代码中的参考点“最接近”的一个。
这称为“词汇范围”，并且已成为标准 40 年以上。

Python 的类成员实际上位于名为 __dict__ 的字典中，并且永远不会通过词法作用域来访问。

如果您不指定 nonlocal 但指定 x = 7，它将创建一个新的局部变量“x”。
如果您指定nonlocal，它将找到“最接近的”“x”并分配给它。
如果您指定nonlocal并且没有“x”，它将给您一条错误消息。

关键字 global 对我来说一直很奇怪，因为它很乐意忽略除最外面的“x”之外的所有其他“x”。

Answer 5

帮助（'非本地'）
nonlocal 语句

<小时>

 nonlocal_stmt ::=“非本地”标识符（“，”标识符）* 
  

nonlocal 语句导致列出的标识符引用
先前在最近的封闭范围中绑定的变量。 这是
很重要，因为绑定的默认行为是搜索
首先是本地命名空间。 该语句允许封装代码
除了全局范围外，重新绑定局部范围之外的变量
（模块）范围。

nonlocal 语句中列出的名称，与
global 语句，必须引用预先存在的绑定
封闭范围（应在其中创建新绑定的范围
无法明确确定）。

nonlocal 语句中列出的名称不得与预定义冲突
本地范围内的现有绑定。

另请参阅：

PEP 3104 - 访问外部作用域中的名称
nonlocal 语句的规范。

相关帮助主题：全局、命名空间

来源：Python 语言参考

Answer 6

引自 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

Answer 7

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)

Answer 8

我个人对“非局部”声明的理解（请原谅，因为我对 Python 和编程很陌生）是“非局部”是一种在迭代函数中使用全局功能而不是代码本身的方法。 如果愿意的话，可以在函数之间使用全局语句。

Answer 9

文档如下所示：

非本地语句导致列出的标识符引用
先前在最近的封闭范围中绑定的变量，不包括
全局变量。 ...

例如，inner() 中的nonlocal foo 可以访问非局部变量foo = 10 在 middle() 中，但不是在 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()

Answer 10

使用“非局部”内部函数（即嵌套内部函数）可以读取和读取 外部父函数的特定变量的“写入”权限。。 非局部只能在内部函数内部使用
例如：

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)

Answer 11

如果普通脚本中有普通函数，则可能有两组变量：

• 顶层函数外部的变量（全局），
• 函数内部定义的变量（局部） >）。

如果您在另一个函数（内部函数）内部定义了一个函数，则可能有三组变量：

• 位于顶层的变量（ global）
• 内部函数中的那些（local）
• 介于两者之间的那些：在外部函数中定义并且对于外部函数来说是局部的，但对于内部函数来说是相对全局的（local ） >nonlocal）

如果您有内部嵌套函数，并且您需要访问外部函数中定义的变量，那么非局部变量就有意义。