Python作用域详解
📊 作用域层次结构
Built-in（内置）作用域 ← 最高层
↑
Global（全局）作用域
↑
Enclosing（闭包）作用域
↑
Local（局部）作用域 ← 最底层
|
🔍 四种作用域详解
1. 局部作用域（Local Scope）
def calculate():
x = 10
y = 20
result = x + y
return result
calculate()
|
2. 闭包作用域/嵌套作用域（Enclosing Scope）
def outer():
x = "outer"
def inner():
y = "inner"
print(f"inner: x={x}, y={y}")
inner()
outer()
|
3. 全局作用域（Global Scope）
GLOBAL_VAR = "I'm global"
def show_global():
print(f"In function: {GLOBAL_VAR}")
show_global()
print(f"Outside: {GLOBAL_VAR}")
|
4. 内置作用域（Built-in Scope）
print(len([1, 2, 3]))
print(type("hello"))
print(max(1, 2, 3))
import builtins
print(dir(builtins)[:10])
|
🎯 LEGB规则
Python查找变量时遵循 LEGB规则（从内到外查找）：
- Local：局部作用域
- Enclosing：闭包作用域
- Global：全局作用域
- Built-in：内置作用域
x = "global"
def outer():
x = "enclosing"
def inner():
x = "local"
print(x)
inner()
outer()
|
x = "global"
def outer():
x = "enclosing"
def inner():
print(x)
inner()
outer()
|
def test():
print(len("hello"))
test()
|
🔑 关键字：global和nonlocal
global关键字
counter = 0
def increment():
global counter
counter += 1
print(f"Counter: {counter}")
increment()
increment()
print(f"Global counter: {counter}")
|
count = 0
def increment_wrong():
count = count + 1
print(count)
|
nonlocal关键字
def outer():
count = 0
def inner():
nonlocal count
count += 1
print(f"Inner: {count}")
inner()
print(f"Outer: {count}")
outer()
|
def outer():
x = "outer"
def middle():
x = "middle"
def inner():
nonlocal x
x = "inner修改了middle的x"
print(f"Inner: {x}")
inner()
print(f"Middle: {x}")
middle()
print(f"Outer: {x}")
outer()
|
⚡ 作用域实战示例
示例1：闭包和状态保持
def make_counter():
count = 0
def counter():
nonlocal count
count += 1
return count
return counter
counter1 = make_counter()
counter2 = make_counter()
print(counter1())
print(counter1())
print(counter2())
print(counter1())
|
示例2：工厂函数
def power_factory(exponent):
"""创建计算幂的函数"""
def power(base):
return base ** exponent
return power
square = power_factory(2)
cube = power_factory(3)
print(square(5))
print(cube(5))
print(square(3))
|
示例3：装饰器中的作用域
def logger(func):
"""记录函数调用的装饰器"""
call_count = 0
def wrapper(*args, **kwargs):
nonlocal call_count
call_count += 1
print(f"调用 {func.__name__} 第{call_count}次")
return func(*args, **kwargs)
return wrapper
@logger
def greet(name):
print(f"Hello, {name}!")
greet("Alice")
greet("Bob")
greet("Charlie")
|
🧪 作用域测试与陷阱
陷阱1：列表推导式中的变量泄露（Python 3中已修复）
x = "原始x"
numbers = [x for x in range(5)]
print(x)
print(numbers)
|
陷阱2：默认参数的作用域
def add_item(item, items=[]):
items.append(item)
return items
print(add_item("apple"))
print(add_item("banana"))
print(add_item("cherry"))
def add_item_correct(item, items=None):
if items is None:
items = []
items.append(item)
return items
print(add_item_correct("apple"))
print(add_item_correct("banana"))
|
陷阱3：循环变量在闭包中的问题
functions = []
for i in range(3):
def show():
print(i)
functions.append(show)
for f in functions:
f()
functions = []
for i in range(3):
def show(x=i):
print(x)
functions.append(show)
for f in functions:
f()
def make_show(i):
def show():
print(i)
return show
functions = [make_show(i) for i in range(3)]
for f in functions:
f()
|
📊 作用域可视化工具
查看局部和全局变量
def example_function(a, b):
local_var = "局部变量"
print("局部变量:", locals())
print("全局变量:", globals().keys())
example_function(1, 2)
|
检查变量是否存在
def check_variables():
x = 10
print('x' in locals())
print('y' in locals())
print('x' in globals())
print('len' in dir(__builtins__))
check_variables()
|
🔧 高级作用域应用
动态作用域模拟（使用闭包）
class DynamicScope:
def __init__(self):
self.scopes = [{}]
def push_scope(self):
self.scopes.append({})
def pop_scope(self):
if len(self.scopes) > 1:
return self.scopes.pop()
return None
def set_var(self, name, value):
self.scopes[-1][name] = value
def get_var(self, name):
for scope in reversed(self.scopes):
if name in scope:
return scope[name]
raise NameError(f"变量 '{name}' 未定义")
ds = DynamicScope()
ds.set_var("x", 10)
ds.push_scope()
ds.set_var("x", 20)
print(ds.get_var("x"))
ds.pop_scope()
print(ds.get_var("x"))
|
上下文管理器中的作用域
import contextlib
@contextlib.contextmanager
def temporary_value(obj, attr, temp_value):
"""临时修改对象的属性"""
original = getattr(obj, attr, None)
setattr(obj, attr, temp_value)
try:
yield
finally:
setattr(obj, attr, original)
class Config:
debug_mode = False
config = Config()
print(f"原始: {config.debug_mode}")
with temporary_value(config, 'debug_mode', True):
print(f"临时: {config.debug_mode}")
print(f"恢复后: {config.debug_mode}")
|
💡 最佳实践总结
- 最小化全局变量：优先使用局部变量和函数参数
- 明确变量作用域：使用有意义的命名区分不同作用域的变量
- 避免副作用：函数尽量不要修改外部作用域的变量
- 合理使用闭包：闭包适合用于创建有状态的行为
- 小心默认参数：使用None作为可变对象的默认值
- 了解LEGB规则：明确变量查找顺序，避免命名冲突
- 适时使用global/nonlocal：只在确实需要修改外部变量时使用
- 保持作用域清晰：避免过深的嵌套，保持代码可读性
掌握Python作用域机制对于编写高质量、可维护的代码至关重要。合理利用作用域可以创建更模块化、更安全的代码结构。
