返回函数

Python 闭包与高阶函数教程

高阶函数与函数返回

高阶函数不仅可以接受函数作为参数，还可以将函数作为返回值。这种特性为函数式编程提供了强大的灵活性。

延迟计算示例

考虑一个求和函数的两种实现方式：

# 立即计算版本
def calc_sum(*args):
    total = 0
    for n in args:
        total += n
    return total

# 延迟计算版本（返回函数）
def lazy_sum(*args):
    def sum_func():
        total = 0
        for n in args:
            total += n
        return total
    return sum_func

调用方式对比：

# 立即计算
result = calc_sum(1, 3, 5, 7, 9)  # 直接返回25

# 延迟计算
sum_func = lazy_sum(1, 3, 5, 7, 9)  # 返回函数对象
result = sum_func()  # 调用时才计算，返回25

闭包(Closure)概念

闭包是指内部函数引用了外部函数的变量，即使外部函数已经执行完毕，这些变量仍然会被保留在内存中。

闭包特性

  1. 每次调用外部函数都会创建一个新的闭包
  2. 闭包会"记住"创建时的环境变量
f1 = lazy_sum(1, 3, 5)
f2 = lazy_sum(1, 3, 5)
print(f1 == f2)  # False - 两个不同的函数对象
print(f1() == f2())  # True - 计算结果相同

闭包陷阱与解决方案

常见陷阱：循环变量引用

def create_funcs():
    funcs = []
    for i in range(3):
        def func():
            return i * i
        funcs.append(func)
    return funcs

f1, f2, f3 = create_funcs()
print(f1(), f2(), f3())  # 输出都是4，不是预期的0,1,4

解决方案1：立即绑定参数

def create_funcs():
    funcs = []
    for i in range(3):
        def make_func(x):
            def func():
                return x * x
            return func
        funcs.append(make_func(i))
    return funcs

解决方案2：使用lambda简化

def create_funcs():
    return [lambda x=i: x * x for i in range(3)]

nonlocal关键字

当闭包需要修改外部变量时，需要使用nonlocal声明：

def counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

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

实践练习：创建计数器

def create_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

# 测试
counterA = create_counter()
print(counterA(), counterA(), counterA())  # 1, 2, 3

counterB = create_counter()
print(counterB(), counterB())  # 1, 2 (独立计数)

最佳实践

  1. 避免引用循环变量：闭包中直接引用循环变量会导致意外行为
  2. 明确变量作用域：修改外部变量时使用nonlocal
  3. 保持闭包轻量：闭包会保留外部变量引用，避免内存泄漏
  4. 考虑函数工厂模式：需要多个相似函数时，闭包是很好的解决方案

现代Python改进

Python 3.8+ 引入了海象运算符(:=)，可以简化某些闭包模式：

def create_counter():
    count = 0
    return lambda: (count := count + 1)

c = create_counter()
print(c(), c(), c())  # 1, 2, 3

总结

闭包是Python中强大的特性，它允许函数：

  • 记住创建时的环境
  • 延迟计算
  • 创建函数工厂
  • 实现装饰器等高级模式

正确理解和使用闭包可以写出更优雅、更强大的Python代码。