Python命名空间与作用域实现

Python使用LEGB规则解析名称，理解其内部实现有助于编写高效代码和调试复杂作用域问题。

LEGB规则

名称查找顺序：

x = 'global'

def outer():
    x = 'enclosing'

    def inner():
        x = 'local'
        print(x)  # 局部优先

    inner()  # 输出: local

outer()

命名空间实现

import sys

def demo():
    local_var = 123
    frame = sys._getframe(0)

    # 局部命名空间（字典或映射）
    print(f"局部变量: {frame.f_locals}")

    # 全局命名空间
    print(f"全局变量键: {list(frame.f_globals.keys())[:5]}...")

    # 内置命名空间
    print(f"内置函数示例: {list(frame.f_builtins.keys())[:5]}...")

demo()

# globals() 和 locals() 的区别
x = 'global'

def test():
    y = 'local'

    # locals() 返回局部命名空间的副本
    local_ns = locals()
    print(f"locals: {local_ns}")

    # globals() 返回全局命名空间
    global_ns = globals()
    print(f'global x: {global_ns["x"]}')

    # 修改 locals() 不影响实际变量
    local_ns['y'] = 'modified'
    print(f"actual y: {y}")  # 仍然是 'local'

test()

闭包捕获机制

def make_counter():
    count = 0

    def counter():
        nonlocal count  # 声明引用外层变量
        count += 1
        return count

    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

# 查看闭包变量
def outer():
    x = 10
    y = 20

    def inner():
        return x + y

    return inner

func = outer()
print(f"自由变量: {func.__code__.co_freevars}")  # ('x', 'y')
print(f"闭包单元: {func.__closure__}")
print(f"x值: {func.__closure__[0].cell_contents}")  # 10
print(f"y值: {func.__closure__[1].cell_contents}")  # 20

Cell 对象与自由变量

def analyze_closure():
    "分析闭包的内部结构"
    value = 42

    def closure():
        return value

    # Code Object 信息
    code = closure.__code__
    print(f"自由变量: {code.co_freevars}")  # ('value',)
    print(f"局部变量: {code.co_varnames}")  # ()
    print(f"参数: {code.co_argcount}")      # 0

    # 闭包单元
    cell = closure.__closure__[0]
    print(f"Cell内容: {cell.cell_contents}")  # 42

    return closure

func = analyze_closure()

# 共享与独立闭包
def create_multipliers():
    return [lambda x, i=i: x * i for i in range(3)]  # i=i 捕获当前值

multipliers = create_multipliers()
print(multipliers[0](10))  # 0
print(multipliers[1](10))  # 10
print(multipliers[2](10))  # 20

# 错误方式：所有lambda共享同一个i
def create_multipliers_wrong():
    return [lambda x: x * i for i in range(3)]  # i引用同一变量

wrong = create_multipliers_wrong()
print(wrong[0](10))  # 20（i最终值为2）
print(wrong[1](10))  # 20
print(wrong[2](10))  # 20

nonlocal 与 global

x = 'global'

def outer():
    x = 'enclosing'

    def inner():
        global x
        x = 'modified global'  # 修改全局x

    inner()
    print(f"outer x: {x}")  # 仍然是 'enclosing'

outer()
print(f"global x: {x}")  # 'modified global'

def outer():
    x = 'enclosing'

    def inner():
        nonlocal x
        x = 'modified enclosing'  # 修改外层x

    inner()
    print(f"outer x: {x}")  # 'modified enclosing'

outer()

作用域陷阱

# 陷阱1：列表推导式的作用域
x = 10
result = [x for x in range(3)]  # Python 3: x不影响外层
print(x)  # 10（Python 3）
# Python 2 中会修改外层x

# 陷阱2：类定义的作用域
x = 'global'

class MyClass:
    x = 'class'
    y = [x for _ in range(1)]  # 使用全局x！

    def method(self):
        return x  # 使用全局x

print(MyClass.y)        # ['global']
print(MyClass().method())  # 'global'

# 类体内访问类变量需通过类名或 locals()
class Fixed:
    x = 'class'
    y = locals()['x']  # 或 Fixed.x（需先定义）

print(Fixed.y)  # 'class'

字节码视角

import dis

def example():
    x = 1       # STORE_FAST
    y = x + 1   # LOAD_FAST, STORE_FAST
    return y

print("函数作用域:")
dis.dis(example)

g = 10
def use_global():
    global g
    return g      # LOAD_GLOBAL

print("\n全局变量:")
dis.dis(use_global)

def use_nonlocal():
    n = 5
    def inner():
        nonlocal n
        n += 1    # LOAD_DEREF, STORE_DEREF
        return n
    return inner

print("\n闭包变量:")
dis.dis(use_nonlocal())

要点总结

1. LEGB规则：Local → Enclosing → Global → Built-in
2. 闭包通过__closure__存储捕获的变量
3. **nonlocal声明引用外层函数变量，global**声明引用全局变量
4. **locals()**返回副本，修改不影响实际变量
5. 列表推导式在Python 3中创建独立作用域