范围规则的简短描述

Question

Python 作用域规则到底是什么？

如果我有一些代码：

code1
class Foo:
   code2
   def spam.....
      code3
      for code4..:
       code5
       x()

在哪里找到x？一些可能的选择包括下面的列表：

1. 在封闭的源文件中
2. 在类命名空间中
3. 在函数定义
4. 中 在 for 循环索引变量中
5. 在 for 循环中

此外还有执行期间的上下文，当函数 spam 时被传递到其他地方。也许 lambda 函数 的传递方式有点不同？

某处必须有一个简单的参考或算法。对于中级 Python 程序员来说，这是一个令人困惑的世界。

Answer 1

实际上，Python 作用域解析的简明规则，来自 学习 Python，第三篇。编辑。。 （这些规则特定于变量名称，而不是属性。如果您引用时不带句点，则这些规则适用。）

LEGB 规则

• Local - 分配的名称函数内的任何方式（def 或 lambda），并且未在该函数中声明为全局

• Enending-function — 在任何和所有静态封闭函数的本地范围内分配的名称 (def 或 lambda），从内部到外部

• Global（模块） - 在模块文件顶层分配的名称，或通过在 中执行 global 语句分配的名称文件内的 def

• Built-in (Python) — 在内置名称模块中预先分配的名称：open、range、SyntaxError 等

因此，在 for 循环中

code1
class Foo:
    code2
    def spam():
        code3
        for code4:
            code5
            x()

没有自己的命名空间。按照 LEGB 顺序，范围将是

• L：def spam 中的本地（在 code3、code4 和 code5 中） )
• E: 任何封闭函数（如果整个示例在另一个 def 中）
• G: 模块中是否有全局声明的 x （在 code1 中） >)?
• B：Python 中的任何内置 x。

x 永远不会在 code2 中找到（即使在您可能期望的情况下，请参阅 Antti 的回答或此处）。

Answer 2

本质上，Python 中唯一引入新作用域的是函数定义。类是一种特殊情况，因为直接在主体中定义的任何内容都放置在类的命名空间中，但不能从它们包含的方法（或嵌套类）中直接访问它们。

在您的示例中，只有 3 个范围将在其中搜索 x：

• spam 的范围 - 包含 code3 和 code5 中定义的所有内容（以及 code4，您的循环变量）

• 全局作用域 - 包含 code1 中定义的所有内容，以及 Foo（以及其后的任何更改）

• 内置命名空间。有一点特殊情况 - 它包含各种 Python 内置函数和类型，例如 len() 和 str()。一般来说，任何用户代码都不应该修改它，因此期望它包含标准函数而不包含其他内容。

仅当您在图片中引入嵌套函数（或 lambda）时才会出现更多作用域。
然而，它们的行为与您的预期非常相似。嵌套函数可以访问本地作用域中的所有内容，以及封闭函数作用域中的任何内容。例如。

def foo():
    x=4
    def bar():
        print x  # Accesses x from foo's scope
    bar()  # Prints 4
    x=5
    bar()  # Prints 5

限制：

可以访问本地函数变量以外的作用域中的变量，但如果没有进一步的语法，则无法重新绑定到新参数。相反，赋值将创建一个新的本地变量，而不是影响父作用域中的变量。例如：

global_var1 = []
global_var2 = 1

def func():
    # This is OK: It's just accessing, not rebinding
    global_var1.append(4) 

    # This won't affect global_var2. Instead it creates a new variable
    global_var2 = 2 

    local1 = 4
    def embedded_func():
        # Again, this doen't affect func's local1 variable.  It creates a 
        # new local variable also called local1 instead.
        local1 = 5
        print local1

    embedded_func() # Prints 5
    print local1    # Prints 4

为了在函数作用域内实际修改全局变量的绑定，您需要使用 global 关键字指定该变量是全局的。例如：

global_var = 4
def change_global():
    global global_var
    global_var = global_var + 1

目前还没有办法对封闭函数作用域中的变量执行相同的操作，但Python 3引入了一个新的关键字“nonlocal”，它将以类似的方式起作用全局，但适用于嵌套函数范围。

Answer 3

关于Python3时间还没有彻底的答案，所以我在这里做了一个答案。此处描述的大部分内容在 4.2.2 解析中详细介绍Python 3 文档的名称。

正如其他答案中所提供的，有 4 个基本范围，即 LEGB，分别用于本地、封闭、全局和内置。除此之外，还有一个特殊的作用域，即类主体，它不包含类内定义的方法的封闭作用域；类主体中的任何赋值都会使变量从那里绑定到类主体中。

特别是，除了 def 和 class 之外，no 块语句创建变量范围。在 Python 2 中，列表推导式不会创建变量作用域，但在 Python 3 中，列表推导式中的循环变量是在新的作用域中创建的。

展示类体的特殊性

x = 0
class X(object):
    y = x
    x = x + 1 # x is now a variable
    z = x

    def method(self):
        print(self.x) # -> 1
        print(x)      # -> 0, the global x
        print(y)      # -> NameError: global name 'y' is not defined

inst = X()
print(inst.x, inst.y, inst.z, x) # -> (1, 0, 1, 0)

因此，与函数体不同的是，您可以在类体中将变量重新分配给同名的变量，从而获得同名的类变量；进一步查找此名称解析
改为类变量。

---

对于许多 Python 新手来说，最大的惊喜之一是 for 循环不会创建变量作用域。在Python 2中，列表推导式也不会创建作用域（而生成器和字典推导式会创建作用域！）相反，它们会泄漏函数或全局作用域中的值：

>>> [ i for i in range(5) ]
>>> i
4

推导式可以用作一种狡猾的（或者可怕的，如果你愿意的话）方式在 Python 2 中的 lambda 表达式中创建可修改的变量 - lambda 表达式确实会创建一个变量作用域，就像 def 语句一样，但在 lambda 中不允许使用任何语句。赋值作为 Python 中的语句意味着 lambda 中不允许进行变量赋值，但列表理解是一个表达式...

此行为已在 Python 3 中修复 - 没有理解表达式或生成器泄漏变量。

---

全局实际上意味着模块范围；主要的Python模块是__main__；所有导入的模块都可以通过 sys.modules 变量访问；要访问__main__，可以使用sys.modules['__main__']，或import __main__；在那里访问和分配属性是完全可以接受的；它们将在主模块的全局范围中显示为变量。

---

如果在当前作用域（类作用域除外）中曾经分配过名称，则它将被视为属于该作用域，否则它将被视为属于分配给该变量的任何封闭作用域（可能不会被分配）还没有，或者根本没有），或者最后是全局范围。如果变量被认为是本地变量，但尚未设置或已被删除，则读取变量值将导致 UnboundLocalError，它是 NameError 的子类。

x = 5
def foobar():
    print(x)  # causes UnboundLocalError!
    x += 1    # because assignment here makes x a local variable within the function

# call the function
foobar()

作用域可以使用 global 关键字声明它明确想要修改全局（模块作用域）变量：

x = 5
def foobar():
    global x
    print(x)
    x += 1

foobar() # -> 5
print(x) # -> 6

即使它被隐藏在封闭作用域中，这也是可能的：

x = 5
y = 13
def make_closure():
    x = 42
    y = 911
    def func():
        global x # sees the global value
        print(x, y)
        x += 1

    return func

func = make_closure()
func()      # -> 5 911
print(x, y) # -> 6 13

在 python 2 中，没有简单的方法来修改全局（模块作用域）变量中的值封闭范围；通常这是通过具有可变值来模拟的，例如长度为 1 的列表：

def make_closure():
    value = [0]
    def get_next_value():
        value[0] += 1
        return value[0]

    return get_next_value

get_next = make_closure()
print(get_next()) # -> 1
print(get_next()) # -> 2

但是在 python 3 中，nonlocal 来救援：

def make_closure():
    value = 0
    def get_next_value():
        nonlocal value
        value += 1
        return value
    return get_next_value

get_next = make_closure() # identical behavior to the previous example.

nonlocal 文档 说

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

即 nonlocal 始终指的是名称已绑定的最内外部非全局范围（即分配给，包括用作 for 目标变量，在 with 子句，或作为函数参数）。

---

任何不被视为当前作用域或任何封闭作用域本地的变量都是全局变量。在模块全局字典中查找全局名称；如果没有找到，则从内置模块中查找全局；模块的名称从 python 2 更改为 python 3；在 python 2 中它是 __builtin__ ，在 python 3 中它现在称为 builtins。如果您分配给内置模块的属性，则此后它将作为可读全局变量对任何模块可见，除非该模块使用其自己的同名全局变量隐藏它们。

---

阅读内置模块也很有用；假设您希望在文件的某些部分使用 python 3 风格的打印函数，但文件的其他部分仍然使用 print 语句。在 Python 2.6-2.7 中，您可以通过以下方式获取 Python 3 print 函数：

import __builtin__

print3 = __builtin__.__dict__['print']

from __future__ import print_function 实际上并不导入 print 函数Python 2 中的任何位置 - 相反，它只是禁用当前模块中 print 语句的解析规则，像任何其他变量标识符一样处理 print，从而允许 print 函数是在内置函数中查找。

Answer 4

范围稍微完整的示例：

from __future__ import print_function  # for python 2 support

x = 100
print("1. Global x:", x)
class Test(object):
    y = x
    print("2. Enclosed y:", y)
    x = x + 1
    print("3. Enclosed x:", x)

    def method(self):
        print("4. Enclosed self.x", self.x)
        print("5. Global x", x)
        try:
            print(y)
        except NameError as e:
            print("6.", e)

    def method_local_ref(self):
        try:
            print(x)
        except UnboundLocalError as e:
            print("7.", e)
        x = 200 # causing 7 because has same name
        print("8. Local x", x)

inst = Test()
inst.method()
inst.method_local_ref()

输出：

1. Global x: 100
2. Enclosed y: 100
3. Enclosed x: 101
4. Enclosed self.x 101
5. Global x 100
6. global name 'y' is not defined
7. local variable 'x' referenced before assignment
8. Local x 200

Answer 5

Python 2.x 的范围规则已在其他答案中概述。我唯一要补充的是，在Python 3.0中，还有非本地作用域的概念（由“nonlocal”关键字表示）。这允许您直接访问外部作用域，并提供了执行一些巧妙技巧的能力，包括词法闭包（没有涉及可变对象的丑陋黑客）。

编辑：这是 PEP ，其中包含更多相关信息。

Answer 6

Python 通常使用三个可用的命名空间来解析变量。

在执行过程中的任何时候，
至少三个嵌套作用域
命名空间可以直接访问：
搜索的最里面的范围
首先，包含本地名称；这
任何封闭函数的命名空间，
从以下内容开始搜索
最近的封闭范围；中间
接下来搜索的范围包含
当前模块的全局名称；和
最外层范围（最后搜索）是
包含内置名称的命名空间。

有两个函数：globals 和 locals，它们向您显示这两个命名空间的内容。

命名空间由包、模块、类、对象构造和函数创建。没有任何其他风格的命名空间。

在这种情况下，对名为 x 的函数的调用必须在本地命名空间或全局命名空间中解析。

在本例中，本地是方法函数 Foo.spam 的主体。

全球性是——好吧——全球性。

规则是搜索方法函数（和嵌套函数定义）创建的嵌套局部空间，然后搜索全局。就是这样。

没有其他范围。 for 语句（以及其他复合语句，如 if 和 try）不会创建新的嵌套作用域。仅定义（包、模块、函数、类和对象实例。）

在类定义中，名称是类命名空间的一部分。例如，code2 必须由类名限定。一般为Foo.code2。然而，self.code2 也可以工作，因为 Python 对象将包含类视为后备。

对象（类的实例）具有实例变量。这些名称位于对象的命名空间中。它们必须由对象限定。 （variable.instance。）

在类方法中，您有局部变量和全局变量。您可以使用 self.variable 来选择实例作为命名空间。您会注意到，self 是每个类成员函数的参数，使其成为本地命名空间的一部分。

请参阅 Python 作用域规则、Python 范围，变量范围。

Answer 7

x在哪里找到？

未找到 x，因为您尚未定义它。 :-) 如果你把它放在那里，它可以在 code1（全局）或 code3（本地）中找到。

code2（类成员）对于同一类的方法内部的代码不可见——您通常可以使用 self.code2 来访问它们。 code4/code5（循环）与 code3 位于相同的范围内，因此如果您在其中写入 x，您将更改 code3 中定义的 x 实例，而不是创建新的 x。

Python 的作用域是静态的，因此如果将“spam”传递给另一个函数，spam 仍然可以访问它来自的模块中的全局变量（在 code1 中定义）以及任何其他包含作用域（见下文）。 code2 成员将再次通过 self 访问。

lambda 与 def 没有什么不同。如果在函数内部使用 lambda，则与定义嵌套函数相同。从 Python 2.2 开始，嵌套作用域可用。在这种情况下，您可以在函数嵌套的任何级别绑定 x，Python 将选取最里面的实例：

x= 0
def fun1():
    x= 1
    def fun2():
        x= 2
        def fun3():
            return x
        return fun3()
    return fun2()
print fun1(), x

2 0

fun3 从最近的包含范围（即与 fun2 关联的函数范围）看到实例 x。但 fun1 中和全局定义的其他 x 实例不受影响。

在nested_scopes之前——在Python 2.1之前和2.1中，除非你特别要求使用from-future-import的功能——fun1和fun2的范围对fun3不可见，所以S.Lott的答案成立，你会得到全局x :

0 0

Answer 8

Python 名称解析 只知道以下几种scope：

1. 内置范围，提供内置函数，例如print、int 或 zip、
2. module 全局作用域，始终是当前模块的顶层，
3. 三个用户定义的作用域可以相互嵌套，即
   1. 函数闭包作用域，来自任何封闭的 def 块、lambda 表达式或推导式。
   2. 函数局部作用域，在def块内，lambda表达式或推导式，
   3. class 范围，在 class 块内。

值得注意的是，其他结构（例如 if、for 或 with 语句）没有自己的作用域。

范围 TLDR：名称的查找从使用该名称的范围开始，然后是任何封闭范围（不包括类范围），再到模块全局变量，然后最后是内置函数 - 使用此搜索顺序中的第一个匹配项。
默认情况下，对范围的赋值是当前范围 - 必须使用特殊形式nonlocal和global来赋值 为来自外部作用域的名称。

最后，推导式和生成器表达式以及 := 赋值表达式在组合时有一个特殊的规则。

---

嵌套作用域和名称解析

这些不同的作用域构建了一个层次结构，内置函数然后全局始终形成基础，闭包、局部变量和类作用域按照词法定义进行嵌套。也就是说，只有源代码中的嵌套很重要，而不是调用堆栈等。

print("builtins are available without definition")

some_global = "1"  # global variables are at module scope

def outer_function():
    some_closure = "3.1"  # locals and closure are defined the same, at function scope
    some_local = "3.2"    # a variable becomes a closure if a nested scope uses it

    class InnerClass:
         some_classvar = "3.3"   # class variables exist *only* at class scope

         def inner_function(self):
             some_local = "3.2"   # locals can replace outer names
             print(some_closure)  # closures are always readable
    return InnerClass

尽管class 创建了一个作用域并且可能具有嵌套的类、函数和推导式，但是class 作用域的名称对于封闭的作用域是不可见的。这将创建以下层次结构：

┎ builtins           [print, ...]
┗━┱ globals            [some_global]
  ┗━┱ outer_function     [some_local, some_closure]
    ┣━╾ InnerClass         [some_classvar]
    ┗━╾ inner_function     [some_local]

名称解析始终从访问名称的当前范围开始，然后沿层次结构向上移动，直到找到匹配项。例如，在 outer_function 和 inner_function 中查找 some_local 从各自的函数开始 - 并立即找到定义的 some_local分别在 outer_function 和 inner_function 中。当名称不是本地名称时，它会从定义它的最近的封闭范围中获取 - 在 inner_function 搜索中查找 some_closure 和 print 直到 <分别是 code>outer_function 和内建函数。

---

范围声明和名称绑定

默认情况下，名称属于它绑定到值的任何范围。在内部作用域中再次绑定相同的名称会创建一个具有相同名称的新变量 - 例如，some_local 分别存在于 outer_function 和 inner_function 中。就作用域而言，绑定包括任何设置名称值的语句 - 赋值语句，还包括 for 循环的迭代变量，或 with 的名称代码>上下文管理器。值得注意的是，del 也算作名称绑定。

当名称必须引用外部变量并且绑定在内部作用域中时，该名称必须声明为非本地名称。不同类型的封闭范围存在单独的声明：nonlocal 始终引用最近的闭包，global 始终引用全局名称。值得注意的是，nonlocal 从不引用全局名称，而 global 会忽略所有同名的闭包。没有引用内置范围的声明。

some_global = "1"

def outer_function():
    some_closure = "3.2"
    some_global = "this is ignored by a nested global declaration"
    
    def inner_function():
        global some_global     # declare variable from global scope
        nonlocal some_closure  # declare variable from enclosing scope
        message = " bound by an inner scope"
        some_global = some_global + message
        some_closure = some_closure + message
    return inner_function

值得注意的是，函数 local 和 nonlocal 是在编译时解析的。 非本地名称​​必须存在于某个外部作用域中。相反，全局名称可以动态定义，并且可以随时在全局范围中添加或删除。

---

推导式和赋值表达式

列表、集合和字典推导式以及生成器表达式的作用域规则几乎与函数相同。同样，赋值表达式的作用域规则几乎与常规名称绑定相同。

推导式和生成器表达式的范围与函数范围相同。作用域中绑定的所有名称（即迭代变量）都是推导式/生成器和嵌套作用域的局部变量或闭包。所有名称（包括可迭代对象）均使用函数内部适用的名称解析进行解析。

some_global = "global"

def outer_function():
    some_closure = "closure"
    return [            # new function-like scope started by comprehension
        comp_local      # names resolved using regular name resolution
        for comp_local  # iteration targets are local
        in "iterable"
        if comp_local in some_global and comp_local in some_global
    ]

:= 赋值表达式适用于最近的函数、类或全局范围。值得注意的是，如果赋值表达式的目标已在最近的范围内声明为非本地或全局，则赋值表达式会像常规赋值一样遵循这一点。

print(some_global := "global")

def outer_function():
    print(some_closure := "closure")

但是，推导式/生成器内的赋值表达式适用于推导式/生成器最近的封闭范围，而不是推导式/生成器本身的范围。当嵌套多个推导式/生成器时，将使用最近的函数或全局作用域。由于推导式/生成器作用域可以读取闭包和全局变量，因此赋值变量在推导式中也是可读的。从推导式分配给类范围是无效的。

print(some_global := "global")

def outer_function():
    print(some_closure := "closure")
    steps = [
        # v write to variable in containing scope
        (some_closure := some_closure + comp_local)
        #                 ^ read from variable in containing scope
        for comp_local in some_global
    ]
    return some_closure, steps

虽然迭代变量对于其所绑定的推导式来说是局部的，但赋值表达式的目标不会创建局部变量，而是从外部作用域读取：

┎ builtins           [print, ...]
┗━┱ globals            [some_global]
  ┗━┱ outer_function     [some_closure]
    ┗━╾ <listcomp>         [comp_local]

Answer 9

在Python中，

任何被赋值的变量都是所在块的局部变量
作业出现。

如果在当前作用域中找不到变量，请参考LEGB命令。