3.4 Python 闭包函数与工厂函数

引言：函数不仅仅是代码

在Python中，函数是第一类对象（first-class objects），这意味着函数可以像其他对象一样被传递、返回和赋值。闭包（Closure） 和工厂函数（Factory Function） 是这一特性的重要应用，它们允许我们创建更加灵活和强大的代码结构。

闭包是指能够访问并记住其词法作用域（lexical scope）中变量的函数，即使函数是在其作用域之外执行。工厂函数则是返回函数的函数，它们利用闭包来创建具有特定行为的函数实例。

在本节中，我们将深入探讨闭包和工厂函数的原理、应用以及它们在实际编程中的强大威力。

第一部分：闭包基础

1.1 什么是闭包？

闭包是一个函数对象，它记住了创建它的环境（作用域）中的变量。即使创建它的函数已经执行完毕，闭包仍然可以访问那些变量。

def outer_function(x):
    # 外层函数
    
    def inner_function(y):
        # 内层函数（闭包）
        return x + y  # 记住了外层函数的变量x
    
    return inner_function  # 返回闭包

# 创建闭包
closure = outer_function(10)  # x被设置为10
result = closure(5)  # 调用闭包，y=5
print(result)  # 输出: 15

1.2 闭包的工作原理

闭包通过函数的__closure__属性实现，该属性包含一个元组，存储了所有被记住的变量。

def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

times3 = make_multiplier(3)
times5 = make_multiplier(5)

print(times3(9))  # 输出: 27
print(times5(3))  # 输出: 15

# 查看闭包内容
print(times3.__closure__[0].cell_contents)  # 输出: 3
print(times5.__closure__[0].cell_contents)  # 输出: 5

1.3 闭包与作用域

闭包可以访问多个作用域级别的变量：

def create_counter():
    count = 0  # 外层函数变量
    
    def increment():
        nonlocal count  # 声明count不是局部变量
        count += 1
        return count
    
    def decrement():
        nonlocal count
        count -= 1
        return count
    
    def get_count():
        return count
    
    # 返回多个闭包
    return increment, decrement, get_count

inc, dec, get = create_counter()

print(inc())  # 输出: 1
print(inc())  # 输出: 2
print(dec())  # 输出: 1
print(get())  # 输出: 1

第二部分：工厂函数

2.1 什么是工厂函数？

工厂函数是返回函数的函数。它们利用闭包来创建具有特定配置或行为的函数实例。

def power_factory(exponent):
    """创建计算幂次的工厂函数"""
    def power(base):
        return base ** exponent
    return power

# 使用工厂函数创建特定函数
square = power_factory(2)
cube = power_factory(3)

print(square(4))  # 输出: 16
print(cube(3))    # 输出: 27

2.2 带参数的工厂函数

工厂函数可以接受参数来定制返回函数的行为：

def make_adder(add_value):
    """创建加法器工厂函数"""
    def adder(number):
        return number + add_value
    return adder

add_five = make_adder(5)
add_ten = make_adder(10)

print(add_five(3))   # 输出: 8
print(add_ten(3))    # 输出: 13

2.3 多功能的工厂函数

工厂函数可以返回具有多个功能的函数集合：

def create_math_operations():
    """创建数学操作工厂函数"""
    operations = {}
    
    def add(x, y):
        return x + y
    
    def multiply(x, y):
        return x * y
    
    def power(x, y):
        return x ** y
    
    # 返回操作字典
    operations['add'] = add
    operations['multiply'] = multiply
    operations['power'] = power
    
    return operations

math_ops = create_math_operations()
print(math_ops['add'](5, 3))        # 输出: 8
print(math_ops['multiply'](5, 3))   # 输出: 15
print(math_ops['power'](2, 3))      # 输出: 8

第三部分：闭包与装饰器

3.1 装饰器中的闭包

装饰器本身就是闭包的一种应用。它们接受一个函数作为参数，并返回一个新的函数（闭包）。

def simple_decorator(func):
    """简单的装饰器，使用闭包记录函数调用"""
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完成")
        return result
    return wrapper

@simple_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Alice")
# 输出:
# 调用函数: say_hello
# Hello, Alice!
# 函数 say_hello 执行完成

3.2 带参数的装饰器

带参数的装饰器实际上是返回装饰器的工厂函数：

def repeat(num_times):
    """带参数的装饰器工厂"""
    def decorator_repeat(func):
        def wrapper_repeat(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper_repeat
    return decorator_repeat

@repeat(num_times=3)
def greet(name):
    print(f"Hello {name}")

greet("Bob")
# 输出:
# Hello Bob
# Hello Bob
# Hello Bob

第四部分：闭包的实际应用

4.1 状态保持

闭包可以用于保持状态，而不需要使用类：

def create_counter():
    """创建计数器闭包"""
    count = 0
    
    def counter():
        nonlocal count
        count += 1
        return count
    
    def reset():
        nonlocal count
        count = 0
        return count
    
    def get_count():
        return count
    
    # 返回多个函数
    return counter, reset, get_count

# 使用计数器
counter, reset, get_count = create_counter()

print(counter())  # 输出: 1
print(counter())  # 输出: 2
print(get_count())  # 输出: 2
print(reset())     # 输出: 0
print(counter())   # 输出: 1

4.2 配置特定的函数

闭包可以用于创建具有特定配置的函数：

def create_greeting(greeting_word, punctuation):
    """创建特定问候语工厂"""
    def greet(name):
        return f"{greeting_word}, {name}{punctuation}"
    return greet

friendly_greet = create_greeting("Hello", "!")
formal_greet = create_greeting("Good day", ".")

print(friendly_greet("Alice"))  # 输出: Hello, Alice!
print(formal_greet("Bob"))      # 输出: Good day, Bob.

4.3 回调函数

闭包常用于创建回调函数，因为它们可以记住创建时的上下文：

def create_callback(prefix):
    """创建带前缀的回调函数"""
    def callback(message):
        print(f"{prefix}: {message}")
    return callback

info_callback = create_callback("INFO")
error_callback = create_callback("ERROR")

info_callback("System started")   # 输出: INFO: System started
error_callback("Disk full")       # 输出: ERROR: Disk full

4.4 数据封装

闭包可以用于模拟私有变量，实现数据封装：

def create_person(name, age):
    """创建人员对象闭包"""
    def get_name():
        return name
    
    def get_age():
        return age
    
    def set_age(new_age):
        nonlocal age
        if new_age > 0:
            age = new_age
    
    def get_info():
        return f"{name}, {age} years old"
    
    # 返回访问方法
    return get_name, get_age, set_age, get_info

get_name, get_age, set_age, get_info = create_person("Alice", 30)

print(get_name())  # 输出: Alice
print(get_age())   # 输出: 30

set_age(31)
print(get_age())   # 输出: 31
print(get_info())  # 输出: Alice, 31 years old

第五部分：工厂函数的实际应用

5.1 数学运算工厂

def math_operation_factory(operation):
    """数学运算工厂函数"""
    if operation == "add":
        def add(a, b):
            return a + b
        return add
    elif operation == "multiply":
        def multiply(a, b):
            return a * b
        return multiply
    elif operation == "power":
        def power(a, b):
            return a ** b
        return power
    else:
        raise ValueError("Unknown operation")

add_func = math_operation_factory("add")
multiply_func = math_operation_factory("multiply")
power_func = math_operation_factory("power")

print(add_func(5, 3))        # 输出: 8
print(multiply_func(5, 3))   # 输出: 15
print(power_func(2, 3))      # 输出: 8

5.2 权限检查工厂

def create_access_checker(allowed_roles):
    """创建权限检查工厂函数"""
    def check_access(user_role):
        return user_role in allowed_roles
    return check_access

admin_checker = create_access_checker(["admin", "superadmin"])
editor_checker = create_access_checker(["admin", "editor"])

print(admin_checker("user"))      # 输出: False
print(admin_checker("admin"))     # 输出: True
print(editor_checker("editor"))   # 输出: True
print(editor_checker("author"))   # 输出: False

5.3 日志记录工厂

def create_logger(log_level):
    """创建日志记录器工厂函数"""
    def log(message):
        print(f"[{log_level}] {message}")
    return log

info_logger = create_logger("INFO")
warning_logger = create_logger("WARNING")
error_logger = create_logger("ERROR")

info_logger("System started")     # 输出: [INFO] System started
warning_logger("Low disk space")  # 输出: [WARNING] Low disk space
error_logger("Disk full")         # 输出: [ERROR] Disk full

5.4 缓存工厂

def create_cached_function(func):
    """创建缓存函数工厂"""
    cache = {}
    
    def cached_func(*args):
        if args in cache:
            print("Returning cached result")
            return cache[args]
        result = func(*args)
        cache[args] = result
        print("Calculating and caching result")
        return result
    
    # 添加清理缓存的方法
    cached_func.clear_cache = lambda: cache.clear()
    
    return cached_func

# 使用缓存工厂
@create_cached_function
def expensive_computation(x, y):
    return x * y

print(expensive_computation(5, 6))  # 输出: Calculating and caching result, 30
print(expensive_computation(5, 6))  # 输出: Returning cached result, 30

# 清理缓存
expensive_computation.clear_cache()
print(expensive_computation(5, 6))  # 输出: Calculating and caching result, 30

第六部分：高级闭包技巧

6.1 闭包与装饰器组合

闭包和装饰器可以组合使用，创建强大的功能：

def retry_on_failure(max_attempts=3, delay=1):
    """重试装饰器工厂"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    if attempts == max_attempts:
                        print(f"函数 {func.__name__} 在 {max_attempts} 次尝试后仍失败")
                        raise
                    print(f"函数 {func.__name__} 第 {attempts} 次尝试失败: {e}")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry_on_failure(max_attempts=3, delay=0.5)
def unreliable_function():
    """模拟不可靠的函数"""
    import random
    if random.random() < 0.7:  # 70%的概率失败
        raise ValueError("随机失败")
    return "成功"

# 测试重试机制
try:
    result = unreliable_function()
    print(f"最终结果: {result}")
except ValueError as e:
    print(f"所有尝试都失败了: {e}")

6.2 闭包与类结合

闭包可以与类结合，提供更灵活的实现：

class FunctionRegistry:
    """函数注册表类，使用闭包"""
    
    def __init__(self):
        self._registry = {}
    
    def register(self, name=None):
        """注册函数装饰器工厂"""
        def decorator(func):
            registry_name = name or func.__name__
            self._registry[registry_name] = func
            return func
        return decorator
    
    def get_function(self, name):
        """获取注册的函数"""
        return self._registry.get(name)
    
    def list_functions(self):
        """列出所有注册的函数"""
        return list(self._registry.keys())

# 使用函数注册表
registry = FunctionRegistry()

@registry.register("add")
def add_numbers(a, b):
    return a + b

@registry.register("multiply")
def multiply_numbers(a, b):
    return a * b

print(registry.list_functions())  # 输出: ['add', 'multiply']
add_func = registry.get_function("add")
print(add_func(5, 3))  # 输出: 8

6.3 动态函数生成

闭包可以用于动态生成函数：

def function_factory(name, operation):
    """动态函数生成工厂"""
    if operation == "add":
        def generated_func(a, b):
            return a + b
    elif operation == "multiply":
        def generated_func(a, b):
            return a * b
    else:
        raise ValueError("Unknown operation")
    
    # 设置函数名
    generated_func.__name__ = name
    return generated_func

# 动态创建函数
dynamic_add = function_factory("custom_add", "add")
dynamic_multiply = function_factory("custom_multiply", "multiply")

print(dynamic_add(5, 3))        # 输出: 8
print(dynamic_multiply(5, 3))   # 输出: 15
print(dynamic_add.__name__)     # 输出: custom_add

第七部分：闭包与作用域

7.1 nonlocal关键字

在Python 3中，nonlocal关键字允许内嵌函数修改封闭函数中的变量：

def outer():
    x = 0
    def inner():
        nonlocal x  # 声明x不是局部变量
        x += 1
        return x
    return inner

counter = outer()
print(counter())  # 输出: 1
print(counter())  # 输出: 2

7.2 闭包与循环变量

在处理循环中的闭包时，需要注意变量绑定问题：

# 常见问题：循环变量绑定
functions = []
for i in range(3):
    def func():
        return i
    functions.append(func)

# 所有函数都返回2，因为它们都引用了同一个变量i
print([f() for f in functions])  # 输出: [2, 2, 2]

# 解决方案1：使用默认参数捕获当前值
functions = []
for i in range(3):
    def func(i=i):  # 使用默认参数捕获当前i的值
        return i
    functions.append(func)

print([f() for f in functions])  # 输出: [0, 1, 2]

# 解决方案2：使用工厂函数
def create_func(i):
    def func():
        return i
    return func

functions = [create_func(i) for i in range(3)]
print([f() for f in functions])  # 输出: [0, 1, 2]

7.3 闭包与全局变量

闭包可以访问全局变量，但修改全局变量需要使用global关键字：

global_var = 10

def outer():
    def inner():
        global global_var  # 声明global_var是全局变量
        global_var += 1
        return global_var
    return inner

increment_global = outer()
print(increment_global())  # 输出: 11
print(increment_global())  # 输出: 12

第八部分：性能考虑与最佳实践

8.1 内存使用考虑

闭包会保持对外部变量的引用，这可能会影响内存使用：

def create_large_closure():
    large_data = [x for x in range(1000000)]  # 大量数据
    def closure():
        return len(large_data)
    return closure

# large_data会一直存在，因为闭包引用它
large_closure = create_large_closure()

8.2 避免不必要的闭包

如果不需要访问外部变量，应该避免使用闭包：

# 不必要的闭包
def unnecessary_closure():
    data = [1, 2, 3]
    def process():
        return sum(data)  # 实际上不需要访问data
    return process

# 更好的方式
def process_data(data):
    return sum(data)

8.3 使用functools.partial

对于简单的函数定制，可以考虑使用functools.partial而不是闭包：

from functools import partial

def multiply(x, y):
    return x * y

# 使用partial而不是闭包
double = partial(multiply, 2)
triple = partial(multiply, 3)

print(double(5))  # 输出: 10
print(triple(5))  # 输出: 15

第九部分：总结

闭包和工厂函数是Python中强大而灵活的特性，它们允许我们：

1. 创建具有记忆功能的函数：闭包可以记住创建时的环境变量
2. 动态生成特定行为的函数：工厂函数可以根据参数返回不同的函数
3. 实现函数定制和配置：通过闭包和工厂函数创建具有特定配置的函数
4. 封装数据和状态：闭包可以用于模拟私有变量和状态保持

在实际应用中，闭包和工厂函数被广泛用于：

• 装饰器的实现：装饰器本身就是闭包的一种应用
• 回调函数的创建：闭包可以记住创建时的上下文
• 配置特定的函数行为：工厂函数可以创建具有特定行为的函数
• 实现部分函数应用：固定函数的一些参数
• 创建带有状态的函数：不需要使用类就能保持状态

掌握闭包和工厂函数不仅有助于编写更优雅的代码，也是理解Python高级特性的重要基础。

思考题：

1. 如何创建一个闭包，能够同时记住多个外部变量？
2. 在什么情况下，使用闭包比使用类更合适？
3. 如何避免闭包中常见的变量绑定问题？
4. 闭包和装饰器之间有什么关系？
5. 如何测试闭包函数的正确性？