Python中变量的作用域（Scope）定义了变量在程序中的可见性和生命周期。其核心规则是**LEGB规则**，即Python解释器按特定顺序搜索命名空间（Namespace）来查找变量名[ref_1][ref_4][ref_5][ref_6]。理解作用域是避免变量访问冲突和编写可预测代码的关键。 ### 1. 作用域层级与LEGB规则 当在代码中访问一个变量名时，Python会按照**L -> E -> G -> B**的顺序逐层向外查找[ref_1][ref_4][ref_5]。 | 作用域层级 | 英文全称 | 查找顺序 | 描述与示例 | | :--- | :--- | :--- | :--- | | **L (Local)** | 局部作用域 | 1 | 当前函数或类方法内部定义的变量。查找首先从这里开始[ref_1][ref_2]。 | | **E (Enclosing)** | 闭包函数外的嵌套作用域 | 2 | 包含当前函数的**外层非全局**作用域，常见于嵌套函数。如果当前函数是一个嵌套函数，则会搜索其外层函数的作用域[ref_1]。 | | **G (Global)** | 全局作用域 | 3 | 在模块（文件）顶层定义的变量。如果变量不在局部或闭包作用域中，则会查找这里[ref_1][ref_2]。 | | **B (Built-in)** | 内置作用域 | 4 | Python内置的命名空间，包含`len`、`print`、`int`等内置函数和异常。这是查找的最后一站[ref_1][ref_5]。 | **代码示例：LEGB查找过程** ```python # G: 全局作用域 global_var = "I'm global" def outer_function(): # E: 闭包作用域 (对inner_function而言) enclosing_var = "I'm in enclosing scope" def inner_function(): # L: 局部作用域 local_var = "I'm local" print(local_var) # 找到 L print(enclosing_var) # L未找到 -> 找到 E print(global_var) # L/E未找到 -> 找到 G print(len([1,2,3])) # L/E/G未找到 -> 找到 B (内置函数len) inner_function() outer_function() # 输出: # I'm local # I'm in enclosing scope # I'm global # 3 ``` ### 2. 变量声明与关键字：`global` 与 `nonlocal` 在作用域内，默认的赋值操作总是在**最内层作用域**创建或修改变量[ref_4]。若需修改外层作用域的变量，必须使用`global`或`nonlocal`关键字显式声明。 | 关键字 | 作用对象 | 功能 | 使用场景与限制 | | :--- | :--- | :--- | :--- | | **`global`** | 全局作用域 (G) | 声明函数内后续引用的变量来自全局作用域，并允许对其进行修改[ref_2][ref_3]。 | 用于在函数内部修改模块级别的变量。 | | **`nonlocal`** | 闭包作用域 (E) | 声明在嵌套函数中，后续引用的变量来自最近的**外层非全局**作用域，并允许修改[ref_1][ref_3]。 | 用于在嵌套函数内部修改其外层函数的局部变量。不能用于全局作用域。 | **代码示例：`global` 与 `nonlocal` 的使用与对比** ```python # --- global 关键字示例 --- count = 0 # 全局变量 def increment_global(): global count # 声明引用全局变量count count += 1 # 修改全局变量 increment_global() print(count) # 输出: 1 # --- nonlocal 关键字示例 --- def outer(): counter = 0 # 外层函数局部变量 (对inner是闭包作用域) def inner(): nonlocal counter # 声明引用外层函数的counter counter += 1 # 修改闭包作用域的变量 return counter return inner func = outer() print(func()) # 输出: 1 print(func()) # 输出: 2 # --- 不使用关键字的陷阱 --- x = 10 def no_keyword(): x = 20 # 这实际上是在局部作用域创建了一个新的局部变量x，而非修改全局x print("Inside:", x) # 输出: Inside: 20 no_keyword() print("Outside:", x) # 输出: Outside: 10 (全局x未被修改) ``` ### 3. 特殊结构的作用域行为 Python中某些语法结构会创建独立的作用域，其行为需要特别注意。 **3.1 类定义的作用域** 类定义会创建一个新的**命名空间**，但它**不会**为类体中定义的变量创建**闭包作用域**。类的方法在查找变量时，无法直接访问类体作用域中的变量，必须通过`self.`或类名来访问[ref_1]。 ```python class MyClass: class_var = "I'm a class variable" # 属于类命名空间 def my_method(self): # 这里无法直接访问 class_var # print(class_var) # 会引发 NameError print(self.class_var) # 正确：通过实例访问 print(MyClass.class_var) # 正确：通过类名访问 obj = MyClass() obj.my_method() ``` **3.2 列表推导式、生成器表达式的作用域** 在 **Python 3** 中，列表推导式、生成器表达式、集合推导式和字典推导式拥有**独立的作用域**。其内部的迭代变量不会泄露到外部作用域[ref_1]。 ```python # Python 3 行为 x = 'outer' numbers = [x for x in range(5)] # 推导式有自己的作用域 print(x) # 输出: 'outer' (外部的x未被覆盖) print(numbers) # 输出: [0, 1, 2, 3, 4] # 注意：在Python 2中，列表推导式没有独立作用域，x会被覆盖为4。 ``` **3.3 `exec()` 和 `eval()` 的作用域** `exec()`和`eval()`可以动态执行代码字符串。它们接受可选的`globals`和`locals`参数来指定执行的命名空间。如果不指定，`eval()`默认使用调用者的局部和全局作用域，而`exec()`的行为略有不同[ref_1]。 ```python code = """ z = x + y # 试图访问外部变量 print(z) """ x, y = 10, 20 # 在指定的命名空间中执行 namespace = {'x': 1, 'y': 2} exec(code, namespace) # 输出: 3 (使用的是namespace中的x和y) # print(z) # 这里会报错NameError，因为z定义在exec的独立命名空间中，未泄露出来。 ``` ### 4. 作用域相关的常见陷阱与最佳实践 **4.1 闭包与延迟绑定** 在循环或延迟执行（如lambda、生成器）中创建闭包时，容易出现“延迟绑定”问题。内部函数引用的是外部变量的**名称**，而非创建时的**值**[ref_1]。 ```python # 陷阱示例：延迟绑定 funcs = [] for i in range(3): def inner(): return i funcs.append(inner) # 循环结束后，i的值为2 print([f() for f in funcs]) # 输出: [2, 2, 2] (所有函数都返回最终的i值) # 解决方案1：使用默认参数绑定当前值 funcs_fixed = [] for i in range(3): def inner(x=i): # 默认参数在定义时求值并绑定 return x funcs_fixed.append(inner) print([f() for f in funcs_fixed]) # 输出: [0, 1, 2] # 解决方案2：使用工厂函数 def make_inner(val): def inner(): return val return inner funcs_factory = [make_inner(i) for i in range(3)] print([f() for f in funcs_factory]) # 输出: [0, 1, 2] ``` **4.2 在局部作用域修改全局可变对象** 无需`global`声明即可修改全局**可变对象**（如列表、字典）的**内容**，因为这不是对变量名本身的重新赋值，而是通过引用进行的原地操作[ref_4]。 ```python my_global_list = [] def append_to_list(): my_global_list.append(1) # 可以，修改的是对象内容 # my_global_list = [1] # 不可以！这试图创建新的局部变量，会报错，除非使用global append_to_list() print(my_global_list) # 输出: [1] ``` **4.3 最佳实践总结** 1. **最小化使用全局变量**：优先使用函数参数和返回值传递数据，避免过度依赖全局状态[ref_2]。 2. **明确变量声明**：在函数内需要修改全局或闭包变量时，始终使用`global`或`nonlocal`关键字，使意图清晰[ref_3]。 3. **注意闭包陷阱**：在循环中创建闭包时，使用默认参数或工厂函数来立即绑定变量的值[ref_1]。 4. **理解特殊结构**：牢记类、推导式、`exec`/`eval`等结构独特的作用域规则。