什么是Python的闭包？ #

请详细说明闭包的概念、工作原理、使用场景、优势以及在实际开发中的应用价值

1. 闭包概述 #

闭包（Closure）是Python中的一种独特的函数机制。简而言之，闭包是指在一个内部函数中，引用了外部函数的变量，而这个外部函数已经执行完毕并返回了内部函数，然而内部函数仍然可以访问这些外部函数中的变量。

核心特点

• 内部函数：闭包涉及内部函数和外部函数
• 变量引用：内部函数引用外部函数的变量
• 状态保持：外部函数执行完毕后，内部函数仍能访问外部变量
• 数据封装：通过闭包可以实现数据的封装和隐藏

2. 基本概念和示例 #

2.1 简单闭包示例 #

# 定义一个外部函数，接受参数x
def outer_function(x):
    # 定义一个内部函数，接受参数y
    def inner_function(y):
        # 内部函数返回x和y的和
        # 注意：这里引用了外部函数的变量x
        return x + y
    # 外部函数返回内部函数
    return inner_function

# 调用外部函数，传入参数10，得到闭包函数
closure_func = outer_function(10)
# 调用闭包函数，传入参数5
result = closure_func(5)
# 打印结果
print(f"闭包函数调用结果: {result}")

# 验证闭包函数仍然可以访问外部变量
print(f"闭包函数类型: {type(closure_func)}")
print(f"闭包函数名称: {closure_func.__name__}")

# 创建多个不同的闭包函数
closure_func_20 = outer_function(20)
closure_func_30 = outer_function(30)

# 测试不同的闭包函数
print(f"闭包函数(20)调用结果: {closure_func_20(5)}")
print(f"闭包函数(30)调用结果: {closure_func_30(5)}")

# 验证每个闭包函数都有独立的状态
print(f"闭包函数(10)和闭包函数(20)是否相同: {closure_func is closure_func_20}")

2.2 闭包的工作原理 #

当外部函数返回内部函数时，内部函数不仅仅带有自己的代码，还会保存其作用域中被引用的变量。 这些变量绑定在内部函数的 __closure__ 属性中。这样，即使外部函数已经完成执行，被内部函数引用的那些变量仍然被“记住”并可以继续访问。

2.2.1 查看闭包内部结构 #

# 定义一个外部函数，接受参数x
def outer_function(x):
    # 定义一个内部函数，接受参数y
    def inner_function(y):
        # 内部函数返回x和y的和
        # 注意：这里引用了外部函数的变量x
        return x + y
    # 外部函数返回内部函数
    return inner_function

# 继续上面的 outer_function 应用
f = outer_function(100)
print(f"f(7) = {f(7)}")  # 输出: 107

# 查看内部函数的 __closure__ 属性
print("闭包的 __closure__ 属性:", f.__closure__)
print("闭包绑定的自由变量:", [cell.cell_contents for cell in f.__closure__])

要点说明：

• __closure__ 属性是一个包含 cell 对象的元组，每个 cell 存储一个被“捕获”的外部变量。
• 上例中，f.__closure__ 只有一个 cell 对象，它的值就是 x=100。

2.2.2 闭包和作用域链 #

闭包依赖于 Python 的词法作用域规则：内部函数会自动捕获其外部作用域内用到的变量，这些变量在外部函数生命周期结束后也不会被销毁。

2.2.3 使用 nonlocal 修改闭包变量 #

通常，闭包内部只能“读取”外部变量。如果想在内部函数中“修改”外部函数的变量，需要使用 nonlocal 关键字。例如：

def make_accumulator(base=0):
    total = base
    def add(num):
        nonlocal total      # 声明 total 是外部（但非全局）变量
        total += num
        return total
    return add

acc = make_accumulator(10)
print(acc(1))  # 11
print(acc(5))  # 16
print(acc(-3)) # 13

要点说明：

• nonlocal 只能用于修改最近一层外部函数的变量。
• 如果不加 nonlocal，赋值会创建内部局部变量，无法修改已绑定的外部变量值。

2.2.4 小结 #

• 闭包本质是“带有环境的函数对象”。
• 闭包可以实现私有变量、“记忆”数据、延迟计算等特性，是函数式编程的重要工具。

3. 闭包的使用场景 #

3.1 函数工厂 #

# 示例1：乘法器工厂
def make_multiplier(n):
    # 外部函数创建乘法器
    def multiplier(x):
        # 内部函数实现乘法运算
        return x * n
    # 返回内部函数
    return multiplier

# 创建不同的乘法器
times3 = make_multiplier(3)
times5 = make_multiplier(5)
times10 = make_multiplier(10)

# 测试乘法器
print(f"3乘以9: {times3(9)}")
print(f"5乘以7: {times5(7)}")
print(f"10乘以4: {times10(4)}")

# 示例2：幂运算工厂
def make_power(exponent):
    # 外部函数创建幂运算函数
    def power_function(base):
        # 内部函数实现幂运算
        return base ** exponent
    # 返回内部函数
    return power_function

# 创建不同的幂运算函数
square = make_power(2)
cube = make_power(3)
fourth_power = make_power(4)

# 测试幂运算函数
print(f"5的平方: {square(5)}")
print(f"3的立方: {cube(3)}")
print(f"2的4次方: {fourth_power(2)}")

# 示例3：字符串处理工厂
def make_string_processor(prefix, suffix):
    # 外部函数创建字符串处理函数
    def process_string(text):
        # 内部函数处理字符串
        return f"{prefix}{text}{suffix}"
    # 返回内部函数
    return process_string

# 创建不同的字符串处理器
html_wrapper = make_string_processor("<div>", "</div>")
bold_wrapper = make_string_processor("**", "**")
quote_wrapper = make_string_processor('"', '"')

# 测试字符串处理器
print(f"HTML包装: {html_wrapper('Hello')}")
print(f"粗体包装: {bold_wrapper('World')}")
print(f"引号包装: {quote_wrapper('Python')}")

3.2 装饰器应用 #

# 示例1：简单的装饰器
def my_decorator(func):
    # 外部函数接受被装饰的函数
    def wrapper(*args, **kwargs):
        # 内部函数包装原函数
        print(f"调用函数: {func.__name__}")
        # 调用原函数
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完成")
        # 返回原函数的结果
        return result
    # 返回包装函数
    return wrapper

# 使用装饰器
@my_decorator
def greet(name):
    # 被装饰的函数
    return f"Hello, {name}!"

# 测试装饰器
result = greet("Alice")
print(f"装饰器结果: {result}")

# 示例2：带参数的装饰器
def repeat(times):
    # 外部函数接受装饰器参数
    def decorator(func):
        # 内部装饰器函数
        def wrapper(*args, **kwargs):
            # 内部包装函数
            results = []
            for i in range(times):
                # 重复调用原函数
                result = func(*args, **kwargs)
                results.append(result)
            return results
        return wrapper
    return decorator

# 使用带参数的装饰器
@repeat(3)
def say_hello(name):
    # 被装饰的函数
    return f"Hello, {name}!"

# 测试带参数的装饰器
results = say_hello("Bob")
print(f"重复调用结果: {results}")

3.3 状态维持 #

# 示例1：银行账户模拟
def create_bank_account(initial_balance=0):
    # 外部函数创建银行账户
    balance = initial_balance

    def deposit(amount):
        # 存款函数
        nonlocal balance
        if amount > 0:
            balance += amount
            return f"存款成功，当前余额: {balance}"
        else:
            return "存款金额必须大于0"

    def withdraw(amount):
        # 取款函数
        nonlocal balance
        if amount > 0 and amount <= balance:
            balance -= amount
            return f"取款成功，当前余额: {balance}"
        elif amount > balance:
            return "余额不足"
        else:
            return "取款金额必须大于0"

    def get_balance():
        # 查询余额函数
        return balance

    def get_statement():
        # 获取账户信息函数
        return f"账户余额: {balance}"

    # 返回账户操作函数
    return {
        'deposit': deposit,
        'withdraw': withdraw,
        'get_balance': get_balance,
        'get_statement': get_statement
    }

# 创建银行账户
account1 = create_bank_account(1000)
account2 = create_bank_account(500)

# 测试账户1
print("账户1操作:")
print(account1['deposit'](200))
print(account1['withdraw'](150))
print(account1['get_statement']())

# 测试账户2
print("\n账户2操作:")
print(account2['deposit'](300))
print(account2['withdraw'](100))
print(account2['get_statement']())

# 验证账户独立性
print(f"\n账户1余额: {account1['get_balance']()}")
print(f"账户2余额: {account2['get_balance']()}")

4. 闭包的优势 #

4.1 避免全局变量 #

# 不使用闭包的方式（使用全局变量）
global_counter = 0

def increment_global():
    # 使用全局变量
    global global_counter
    global_counter += 1
    return global_counter

def get_global_counter():
    # 获取全局变量
    return global_counter

# 测试全局变量方式
print("使用全局变量:")
print(f"计数: {increment_global()}")
print(f"计数: {increment_global()}")
print(f"计数: {increment_global()}")

# 使用闭包的方式
def create_counter_closure(initial=0):
    # 使用闭包避免全局变量
    count = initial

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

    def get_count():
        return count

    return increment, get_count

# 创建多个独立的计数器
counter1_inc, counter1_get = create_counter_closure(0)
counter2_inc, counter2_get = create_counter_closure(10)

# 测试闭包方式
print("\n使用闭包:")
print(f"计数器1: {counter1_inc()}")
print(f"计数器1: {counter1_inc()}")
print(f"计数器2: {counter2_inc()}")
print(f"计数器2: {counter2_inc()}")

# 验证独立性
print(f"\n计数器1当前值: {counter1_get()}")
print(f"计数器2当前值: {counter2_get()}")
print(f"全局计数器值: {get_global_counter()}")

4.2 数据封装 #

# 示例：配置管理器
def create_config_manager():
    # 外部函数创建配置管理器
    config = {}

    def set_config(key, value):
        # 设置配置项
        config[key] = value
        return f"配置项 {key} 已设置为 {value}"

    def get_config(key):
        # 获取配置项
        return config.get(key, None)

    def get_all_config():
        # 获取所有配置项
        return config.copy()

    def update_config(updates):
        # 批量更新配置项
        config.update(updates)
        return f"已更新 {len(updates)} 个配置项"

    def clear_config():
        # 清空配置项
        config.clear()
        return "配置已清空"

    # 返回配置管理函数
    return {
        'set': set_config,
        'get': get_config,
        'get_all': get_all_config,
        'update': update_config,
        'clear': clear_config
    }

# 创建配置管理器
config_manager = create_config_manager()

# 测试配置管理器
print("配置管理器测试:")
print(config_manager['set']('database_url', 'localhost:5432'))
print(config_manager['set']('debug_mode', True))
print(config_manager['set']('max_connections', 100))

print(f"\n获取数据库URL: {config_manager['get']('database_url')}")
print(f"获取调试模式: {config_manager['get']('debug_mode')}")
print(f"获取最大连接数: {config_manager['get']('max_connections')}")

print(f"\n所有配置: {config_manager['get_all']()}")

# 批量更新配置
updates = {'timeout': 30, 'retry_count': 3}
print(config_manager['update'](updates))
print(f"更新后配置: {config_manager['get_all']()}")

# 验证数据封装
print(f"\n配置管理器类型: {type(config_manager)}")
print(f"配置管理器方法: {list(config_manager.keys())}")

5. Cell对象和closure属性 #

5.1 访问闭包变量 #

# 定义一个闭包函数
def outer_function(x):
    # 外部函数定义变量x
    def inner_function(y):
        # 内部函数引用外部变量x
        return x + y
    # 返回内部函数
    return inner_function

# 创建闭包函数
closure_func = outer_function(10)

# 访问闭包的__closure__属性
print(f"闭包函数: {closure_func}")
print(f"闭包属性: {closure_func.__closure__}")
print(f"闭包属性类型: {type(closure_func.__closure__)}")

# 访问cell对象
if closure_func.__closure__:
    print(f"Cell对象数量: {len(closure_func.__closure__)}")
    for i, cell in enumerate(closure_func.__closure__):
        print(f"Cell {i}: {cell}")
        print(f"Cell {i} 内容: {cell.cell_contents}")
        print(f"Cell {i} 类型: {type(cell.cell_contents)}")

# 创建多个闭包函数
closure_func_20 = outer_function(20)
closure_func_30 = outer_function(30)

# 比较不同闭包函数的cell对象
print(f"\n闭包函数(10)的cell内容: {closure_func.__closure__[0].cell_contents}")
print(f"闭包函数(20)的cell内容: {closure_func_20.__closure__[0].cell_contents}")
print(f"闭包函数(30)的cell内容: {closure_func_30.__closure__[0].cell_contents}")

# 验证cell对象的独立性
print(f"\n闭包函数(10)和闭包函数(20)的cell对象是否相同: {closure_func.__closure__[0] is closure_func_20.__closure__[0]}")

5.2 闭包变量的修改 #

5.2.1 使用nonlocal修改闭包变量 #

# 示例1：使用nonlocal修改闭包变量
def create_mutable_closure(initial_value):
    # 外部函数定义可变变量
    value = initial_value

    def get_value():
        # 获取变量值
        return value

    def set_value(new_value):
        # 设置变量值
        nonlocal value
        value = new_value
        return f"值已设置为: {value}"

    def increment():
        # 增加变量值
        nonlocal value
        value += 1
        return f"值已增加为: {value}"

    # 返回操作函数
    return get_value, set_value, increment

# 创建可变闭包
get_val, set_val, inc_val = create_mutable_closure(0)

# 测试可变闭包
print("可变闭包测试:")
print(f"初始值: {get_val()}")
print(inc_val())
print(inc_val())
print(set_val(100))
print(f"当前值: {get_val()}")

5.2.2 闭包变量的引用计数 #

# 示例2：闭包变量的引用计数
def create_reference_counter():
    # 外部函数定义引用计数
    ref_count = 0

    def add_reference():
        # 增加引用计数
        nonlocal ref_count
        ref_count += 1
        return f"引用计数: {ref_count}"

    def remove_reference():
        # 减少引用计数
        nonlocal ref_count
        if ref_count > 0:
            ref_count -= 1
        return f"引用计数: {ref_count}"

    def get_reference_count():
        # 获取引用计数
        return ref_count

    # 返回引用计数函数
    return add_reference, remove_reference, get_reference_count

# 创建引用计数器
add_ref, remove_ref, get_ref = create_reference_counter()

# 测试引用计数器
print("\n引用计数器测试:")
print(add_ref())
print(add_ref())
print(add_ref())
print(remove_ref())
print(f"当前引用计数: {get_ref()}")

6. 延迟计算和记忆化 #

6.1 延迟计算 #

# 示例1：延迟计算工厂
def create_lazy_calculator():
    # 外部函数创建延迟计算器
    cache = {}

    def lazy_calculate(operation, *args):
        # 内部函数实现延迟计算
        key = (operation, args)

        if key not in cache:
            # 如果缓存中没有结果，进行计算
            if operation == 'add':
                result = sum(args)
            elif operation == 'multiply':
                result = 1
                for arg in args:
                    result *= arg
            elif operation == 'power':
                result = args[0] ** args[1]
            else:
                result = None

            # 将结果存入缓存
            cache[key] = result
            print(f"计算 {operation}{args} = {result}")
        else:
            # 如果缓存中有结果，直接返回
            print(f"从缓存获取 {operation}{args} = {cache[key]}")

        return cache[key]

    def get_cache():
        # 获取缓存内容
        return cache

    def clear_cache():
        # 清空缓存
        cache.clear()
        return "缓存已清空"

    # 返回延迟计算函数
    return lazy_calculate, get_cache, clear_cache

# 创建延迟计算器
calc, get_cache, clear_cache = create_lazy_calculator()

# 测试延迟计算
print("延迟计算测试:")
result1 = calc('add', 1, 2, 3, 4, 5)
result2 = calc('multiply', 2, 3, 4)
result3 = calc('power', 2, 10)

# 重复计算（从缓存获取）
result4 = calc('add', 1, 2, 3, 4, 5)
result5 = calc('multiply', 2, 3, 4)

print(f"\n缓存内容: {get_cache()}")

6.2 记忆化装饰器 #

# 示例1：简单的记忆化装饰器
def memoize(f):
    # 外部函数创建记忆化装饰器
    cache = {}

    def memoized_function(*args):
        # 内部函数实现记忆化
        if args not in cache:
            # 如果缓存中没有结果，调用原函数
            cache[args] = f(*args)
            print(f"计算 f{args} = {cache[args]}")
        else:
            # 如果缓存中有结果，直接返回
            print(f"从缓存获取 f{args} = {cache[args]}")

        return cache[args]

    # 返回记忆化函数
    return memoized_function

# 使用记忆化装饰器
@memoize
def slow_function(x):
    # 模拟耗时计算
    import time
    time.sleep(0.1)  # 模拟计算时间
    return x * x

# 测试记忆化装饰器
print("记忆化装饰器测试:")
result1 = slow_function(5)
result2 = slow_function(5)  # 第二次调用从缓存获取
result3 = slow_function(10)
result4 = slow_function(10)  # 第二次调用从缓存获取

# 示例2：带参数的记忆化装饰器
def memoize_with_limit(max_size=100):
    # 外部函数创建带限制的记忆化装饰器
    def decorator(f):
        cache = {}

        def memoized_function(*args):
            # 内部函数实现带限制的记忆化
            if args not in cache:
                # 如果缓存已满，删除最旧的条目
                if len(cache) >= max_size:
                    # 删除第一个条目
                    oldest_key = next(iter(cache))
                    del cache[oldest_key]

                # 计算并缓存结果
                cache[args] = f(*args)
                print(f"计算 f{args} = {cache[args]}")
            else:
                # 从缓存获取结果
                print(f"从缓存获取 f{args} = {cache[args]}")

            return cache[args]

        return memoized_function
    return decorator

# 使用带限制的记忆化装饰器
@memoize_with_limit(max_size=3)
def fibonacci(n):
    # 斐波那契数列计算
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 测试带限制的记忆化装饰器
print("\n带限制的记忆化装饰器测试:")
result1 = fibonacci(5)
result2 = fibonacci(6)
result3 = fibonacci(7)
result4 = fibonacci(5)  # 从缓存获取

7. 实际应用场景 #

7.1 事件处理系统 #

# 示例：事件监听器
def create_event_listener():
    # 外部函数创建事件监听器
    listeners = {}

    def add_listener(event_type, callback):
        # 添加事件监听器
        if event_type not in listeners:
            listeners[event_type] = []
        listeners[event_type].append(callback)
        return f"已添加 {event_type} 事件监听器"

    def remove_listener(event_type, callback):
        # 移除事件监听器
        if event_type in listeners and callback in listeners[event_type]:
            listeners[event_type].remove(callback)
            return f"已移除 {event_type} 事件监听器"
        return f"未找到 {event_type} 事件监听器"

    def emit_event(event_type, *args, **kwargs):
        # 触发事件
        if event_type in listeners:
            for callback in listeners[event_type]:
                callback(*args, **kwargs)
            return f"已触发 {event_type} 事件"
        return f"未找到 {event_type} 事件监听器"

    def get_listeners(event_type):
        # 获取事件监听器
        return listeners.get(event_type, [])

    # 返回事件处理函数
    return add_listener, remove_listener, emit_event, get_listeners

# 创建事件监听器
add_listener, remove_listener, emit_event, get_listeners = create_event_listener()

# 定义事件处理函数
def on_user_login(user_id):
    print(f"用户 {user_id} 已登录")

def on_user_logout(user_id):
    print(f"用户 {user_id} 已登出")

def on_data_update(data):
    print(f"数据已更新: {data}")

# 添加事件监听器
print("添加事件监听器:")
print(add_listener('login', on_user_login))
print(add_listener('logout', on_user_logout))
print(add_listener('data_update', on_data_update))

# 触发事件
print("\n触发事件:")
print(emit_event('login', 'user123'))
print(emit_event('logout', 'user123'))
print(emit_event('data_update', {'name': 'Alice', 'age': 30}))

# 获取事件监听器
print(f"\n登录事件监听器: {get_listeners('login')}")
print(f"登出事件监听器: {get_listeners('logout')}")

7.2 配置管理 #

# 示例：应用配置管理
def create_app_config():
    # 外部函数创建应用配置
    config = {
        'app_name': 'MyApp',
        'version': '1.0.0',
        'debug': False,
        'database': {
            'host': 'localhost',
            'port': 5432,
            'name': 'myapp_db'
        }
    }

    def get_config(key):
        # 获取配置项
        keys = key.split('.')
        value = config
        for k in keys:
            if isinstance(value, dict) and k in value:
                value = value[k]
            else:
                return None
        return value

    def set_config(key, value):
        # 设置配置项
        keys = key.split('.')
        current = config
        for k in keys[:-1]:
            if k not in current:
                current[k] = {}
            current = current[k]
        current[keys[-1]] = value
        return f"配置项 {key} 已设置为 {value}"

    def update_config(updates):
        # 批量更新配置
        for key, value in updates.items():
            set_config(key, value)
        return f"已更新 {len(updates)} 个配置项"

    def get_all_config():
        # 获取所有配置
        return config.copy()

    # 返回配置管理函数
    return get_config, set_config, update_config, get_all_config

# 创建配置管理器
get_config, set_config, update_config, get_all_config = create_app_config()

# 测试配置管理
print("配置管理测试:")
print(f"应用名称: {get_config('app_name')}")
print(f"数据库主机: {get_config('database.host')}")
print(f"数据库端口: {get_config('database.port')}")

# 更新配置
print(set_config('debug', True))
print(set_config('database.host', '192.168.1.100'))

# 批量更新配置
updates = {
    'version': '1.1.0',
    'database.port': 3306,
    'database.name': 'myapp_prod'
}
print(update_config(updates))

print(f"\n所有配置: {get_all_config()}")

8. 总结 #

8.1 核心要点总结 #

方面	说明	示例
定义	内部函数引用外部函数变量	def outer(x): def inner(y): return x + y
特点	外部函数执行完毕后仍能访问变量	状态保持
优势	避免全局变量，数据封装	模块化，易维护
应用	函数工厂，装饰器，状态维持	计数器，配置管理

8.2 使用场景总结 #

1. 函数工厂：创建带有状态的函数
2. 装饰器：包装函数，添加功能
3. 状态维持：维护函数内部状态
4. 数据封装：隐藏实现细节
5. 事件处理：管理事件监听器
6. 配置管理：管理应用配置
7. 延迟计算：实现缓存和记忆化

8.3 优势总结 #

1. 避免全局变量：减少全局变量污染
2. 数据封装：隐藏内部实现细节
3. 状态保持：维护函数内部状态
4. 模块化：提高代码模块化程度
5. 可维护性：提高代码可维护性
6. 可重用性：创建可重用的函数

8.4 注意事项 #

1. 内存泄漏：注意闭包可能导致的内存泄漏
2. 变量修改：使用nonlocal关键字修改闭包变量
3. 性能考虑：闭包可能影响性能
4. 调试困难：闭包可能增加调试难度
5. 理解成本：需要理解闭包的工作原理

8.5 最佳实践 #

1. 明确用途：明确闭包的使用目的
2. 避免过度使用：不要过度使用闭包
3. 文档说明：为闭包添加文档说明
4. 测试验证：充分测试闭包功能
5. 性能优化：注意闭包的性能影响

8.6 实际应用价值 #

• 代码组织：提高代码组织性和模块化
• 状态管理：有效管理函数状态
• 功能扩展：通过装饰器扩展功能
• 数据安全：通过封装保护数据
• 开发效率：提高开发效率和代码质量

9.参考回答 #

简明定义（20秒）
闭包就是一个函数，它“记住”了自己定义时所处的外部作用域，即使这个外部函数已经执行完并返回，内部函数依然可以访问外部的变量。
本质是“函数+环境”，实现数据封装和状态保持。

工作原理（30秒）
当一个内部函数引用了其外部（但非全局）函数的变量时，并且外部函数的返回值是这个内部函数，就形成了闭包。
这些被引用的外部变量并不会因为外部函数结束而消失，而是被内部函数继续持有，存储在函数对象的特殊属性里。

实际价值（30秒）

• 可用于创建带有“私有状态”的函数，无需类也能实现数据封装和状态管理；
• 在装饰器、回调、函数工厂等场景下，提供灵活的功能扩展与代码复用；
• 有利于避免全局变量、提升代码的安全性和模块化。

常见应用场景（20秒）

• 工厂函数、装饰器、回调、延迟计算、记忆化函数、事件/配置管理等。

优势与注意点（20秒）
优势是灵活、简洁，可以让函数天然带“记忆”。注意闭包变量通常是只读的，若需修改应使用 nonlocal 关键字。

一句话总结（10秒）
闭包就是让一个函数携带并保护它所需的外部数据，实现状态保持和数据封装，是函数式编程的重要基石。