什么是函数嵌套变量？

在Python中，函数可以定义在其他函数内部，形成函数嵌套结构。这种结构中，内部函数可以访问外部函数的变量，这种变量称为嵌套变量或非局部变量。

理解嵌套变量的关键在于掌握Python的变量作用域规则：

• 局部作用域(Local) - 函数内部定义的变量
• 嵌套作用域(Enclosing) - 外层函数中定义的变量
• 全局作用域(Global) - 模块级别定义的变量
• 内置作用域(Built-in) - Python内置的变量

基本用法与示例

def outer():
    message = "Hello from outer!"  # 外部函数变量
    
    def inner():
        print(message)  # 内部函数访问外部变量
        
    inner()

outer()  # 输出: Hello from outer!

def counter():
    count = 0
    
    def increment():
        nonlocal count  # 声明为非局部变量
        count += 1
        return count
        
    return increment

c = counter()
print(c())  # 输出: 1
print(c())  # 输出: 2
print(c())  # 输出: 3

def power_factory(exponent):
    # 外部函数接收参数
    def power(base):
        # 内部函数使用外部函数的变量
        return base ** exponent
    return power

# 创建平方函数
square = power_factory(2)
print(square(3))  # 输出: 9
print(square(4))  # 输出: 16

# 创建立方函数
cube = power_factory(3)
print(cube(2))  # 输出: 8
print(cube(3))  # 输出: 27

高级应用场景

def logger(func):
    # 外部函数接收函数作为参数
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完毕")
        return result
    return wrapper

@logger
def add(a, b):
    return a + b

print(add(3, 5))
# 输出:
# 调用函数: add
# 函数 add 执行完毕
# 8

def create_account(initial_balance):
    balance = initial_balance
    
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
        
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            return "余额不足"
        balance -= amount
        return balance
        
    def get_balance():
        return balance
        
    return {'deposit': deposit, 'withdraw': withdraw, 'get_balance': get_balance}

# 使用示例
account = create_account(1000)
print(account['get_balance']())  # 1000
print(account['deposit'](500))   # 1500
print(account['withdraw'](200))  # 1300
print(account['get_balance']())  # 1300

常见问题与注意事项

• 变量查找顺序：Python按照LEGB规则查找变量(Local → Enclosing → Global → Built-in)
• 避免循环引用：嵌套函数引用外部变量可能导致内存泄漏
• nonlocal vs global：
  • nonlocal用于修改嵌套作用域中的变量
  • global用于修改全局作用域中的变量
• 闭包变量的延迟绑定：在循环中创建闭包时需要注意变量绑定时机
• 性能考量：嵌套函数会增加函数调用开销，在性能关键代码中需谨慎使用