Python基础语法(十二)：闭包与装饰器

原创 已于 2025-06-10 16:25:56 修改 · 1k 阅读 · 15 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #开发语言

于 2025-05-22 15:47:57 首次发布

Python中的闭包详解

闭包是Python中一个强大而优雅的特性，它可以让函数"记住"它被创建时的环境。

一、什么是闭包？

闭包是一个函数对象，它记住了创建它的环境中的变量值，即使那个环境已经不存在了。简单来说，闭包是"带着环境的函数"。比如我们调用一个带有返回值的函数 x，此时函数 x 为我们返回一个函数 y，这个函数 y 就被称作闭包。私有数据，外部无法直接访问（闭包的核心作用）。

生活比喻

想象你有一个智能水杯：

  1. 你设置它记住你喜欢的温度（外部变量）
  2. 即使你离开厨房（外部函数已执行完毕）
  3. 每次喝水时，它依然保持你设置的温度（保持对外部变量的访问）

二、闭包的三个必要条件

  1. 必须有一个嵌套函数（函数内部定义函数）
  2. 嵌套函数必须引用外部函数中的变量
  3. 外部函数必须返回嵌套函数

三、为什么需要闭包？

闭包是编程语言中一个非常重要的概念，它的存在解决了几个关键问题。

1. 数据封装与私有状态

问题：如何让函数记住某些状态，同时不暴露给外部？

闭包解决方案：

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 create_counter():
    """
    外层函数：定义并初始化计数器变量
    返回内层函数形成闭包
    """
    count = 0  # 自由变量（将被闭包记住的变量）

    def counter():
        """
        内层函数：实际执行计数操作的闭包函数
        每次调用会修改并返回最新的计数值
        """
        # nonlocal 是一个关键字，用于在嵌套函数中声明某个变量不属于当前函数的局部作用域，而是属于外层嵌套函数的作用域
        nonlocal count  # 声明使用外层函数的count变量（Python3需要）
        count += 1  # 修改外层函数的变量
        return count  # 返回最新计数值

    return counter  # 返回内层函数（形成闭包）


# 使用示例 --------------------------------------------------
# 创建计数器实例（实际得到的是闭包函数）
my_counter = create_counter()

# 第一次调用：初始化count为0后+1，返回1
print(my_counter())  # 输出：1

# 第二次调用：记住之前的count值1，+1后返回2
print(my_counter())  # 输出：2

# 创建另一个独立计数器实例
another_counter = create_counter()
print(another_counter())  # 输出：1（独立计数）

优势：

  • count变量对外完全隐藏
  • 只能通过increment函数修改
  • 实现了类似面向对象中私有变量的效果

2. 保持函数上下文

问题：函数执行完毕后，局部变量通常会被销毁，如何保留这些变量？

闭包解决方案：

def greeting(name):
    def message():
        return f"Hello, {name}!"  # 记住name参数
    return message

greet_john = greeting("John")
print(greet_john())  # Hello, John! (即使greeting已执行完毕)

优势：

  • 函数可以"记住"创建时的环境
  • 延迟执行时仍能访问原始数据
  • 特别适合回调函数场景

3. 函数工厂模式

问题：如何动态创建功能相似但配置不同的函数？

闭包解决方案：

def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(4))  # 16 (4²)
print(cube(4))    # 64 (4³)

优势：

  • 避免重复编写相似函数
  • 配置与逻辑分离
  • 运行时动态生成函数

4. 装饰器实现基础

问题：如何不修改原函数代码就增强函数功能？

闭包解决方案：

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

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

print(add(2, 3))  # 先打印日志，再计算结果

优势：

  • 实现装饰器模式
  • 横切关注点分离(AOP)
  • 代码复用性高

5. 回调函数保持状态

问题：事件回调时如何访问原始数据？

闭包解决方案：

def on_button_click(button_id):
    def callback():
        print(f"Button {button_id} clicked")
    return callback

button1_click = on_button_click(1)
button2_click = on_button_click(2)

# 模拟按钮点击
button1_click()  # Button 1 clicked
button2_click()  # Button 2 clicked

优势：

  • 回调函数可以携带额外信息
  • 避免使用全局变量
  • 事件处理更灵活

6. 函数式编程支持

问题：如何实现函数式编程中的部分应用和柯里化？

闭包解决方案：

def add(a):
    def add_b(b):
        return a + b
    return add_b

add5 = add(5)  # 部分应用
print(add5(3))  # 8

优势：

  • 支持函数式编程范式
  • 实现柯里化(currying)
  • 创建更灵活的函数组合

四、为什么不用类替代闭包？

虽然类也能实现类似效果，但闭包有独特优势：

  1. 更轻量：不需要定义整个类
  2. 更简洁：对于简单状态管理代码更少
  3. 更函数式：符合函数式编程风格
  4. 更专注：只解决状态保持这一个问题

实际应用场景

  1. 装饰器：Python装饰器的实现基础
  2. 回调函数：GUI编程、事件处理
  3. 函数工厂：DRY(Don’t Repeat Yourself)原则
  4. 延迟计算：需要时才计算值
  5. 单方法对象：替代只有一个方法的类

闭包的存在让函数不再是孤立的代码块，而是可以携带环境的可执行单元，大大增强了函数的表达能力和灵活性。

基本示例

def outer_func(x):  # 外部函数
    def inner_func(y):  # 内部函数(闭包)
        return x + y  # 使用了外部函数的变量x
    return inner_func  # 返回内部函数

closure = outer_func(10)  # closure现在是一个闭包
print(closure(5))  # 输出15，记住了x=10

五、闭包的典型应用

1. 计数器实现

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

my_counter = counter()
print(my_counter())  # 1
print(my_counter())  # 2
print(my_counter())  # 3

2. 函数工厂

def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(4))  # 16 (4的平方)
print(cube(4))    # 64 (4的立方)

3. 装饰器基础

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@logger
def say_hello(name):
    print(f"你好, {name}!")

say_hello("世界")  # 先打印日志，再执行函数

六、闭包的高级用法

1. 保持状态

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

account = bank_account(100)
print(account['deposit'](50))   # 150
print(account['withdraw'](75))  # 75

2. 参数化回调

def callback_factory(prefix):
    def callback(message):
        print(f"{prefix}: {message}")
    return callback

success = callback_factory("成功")
error = callback_factory("错误")

success("操作完成")  # 输出: 成功: 操作完成
error("发生问题")    # 输出: 错误: 发生问题

闭包的注意事项

  1. 变量绑定时机：闭包中的变量是在函数被调用时查找的，不是定义时

    def create_multipliers():
    return [lambda x: i * x for i in range(5)]

for m in create_multipliers():
    print(m(2))  # 全部输出8，因为i最后是4

  2. 使用nonlocal：Python 3中要修改外部变量需要使用nonlocal声明

  3. 内存泄漏：闭包会保持对外部变量的引用，可能导致内存无法释放

七、闭包与普通函数的区别

特性普通函数闭包
访问外部变量不能能(创建时的环境变量)
状态保持无有
内存占用较小较大(因为要保存环境)
典型用途通用功能实现装饰器、回调、函数工厂等高级场景

闭包就像给函数装了一个"记忆背包"，让它即使离开创建它的环境，也能记住需要的东西。这是Python函数式编程的重要特性之一！

八、装饰器与闭包的关系

装饰器和闭包是Python中两个密切相关的重要概念。让我为你详细解释它们之间的关系和区别。

1. 装饰器本质上是闭包的应用

装饰器实际上是闭包的一种特殊应用。每个装饰器都是一个闭包，因为它：

  1. 是一个嵌套函数结构
  2. 内部函数引用了外部函数的变量（通常是传入的函数）
  3. 返回内部函数

示例对比

闭包示例：

def outer_func(msg):
    def inner_func():
        print(msg)  # 引用了外部变量msg
    return inner_func  # 返回内部函数

closure = outer_func("Hello")
closure()  # 输出: Hello

装饰器示例：

def decorator(func):  # 外部函数接收一个函数
    def wrapper():
        print("Before")  # 添加额外功能
        func()         # 调用原函数
        print("After")  # 添加额外功能
    return wrapper     # 返回内部函数

@decorator
def say_hello():
    print("Hello")

say_hello()
# 输出:
# Before
# Hello
# After

可以看到，装饰器完全符合闭包的三个特征。

2. 装饰器是闭包的高级应用

装饰器将闭包的概念提升到了一个新的层次：

  1. 专门用途：专门用于修改或增强函数行为
  2. 语法糖：提供了@符号的简洁语法
  3. 标准化：形成了一种通用的设计模式

3. 关键区别

特性闭包装饰器
主要目的保持状态/封装变量修改或增强函数行为
语法形式普通函数嵌套使用@符号的语法糖
参数传递可以接受任意参数固定接收一个函数作为参数
返回类型可以返回任何类型必须返回一个可调用对象(通常是函数)
使用场景更通用更专注于函数增强

4. 装饰器如何利用闭包特性

装饰器利用了闭包的三个关键特性：

  1. 函数嵌套：装饰器函数内部定义包装函数
  2. 变量捕获：包装函数记住并访问了原函数(func)
  3. 函数返回：返回包装函数替代原函数

5. 实际案例分析

闭包实现的装饰器

# 定义一个计数器装饰器
def counter_decorator(func):
    """
    装饰器函数：用于统计目标函数被调用的次数
    参数：
        func: 要被装饰的原始函数
    返回：
        wrapper: 包装后的新函数
    """
    # 调用次数计数器（使用可变对象保存状态）
    count = [0]  
    
    def wrapper(*args, **kwargs):
        """
        包装函数：在原始函数执行前后添加额外功能
        *args: 接收任意位置参数
        **kwargs: 接收任意关键字参数
        """
        count[0] += 1  # 每次调用时计数器+1
        print(f"函数 '{func.__name__}' 已被调用 {count[0]} 次")
        
        # 执行原始函数并返回结果（保持原有功能不变）
        result = func(*args, **kwargs)
        
        # 可选：在函数执行后添加其他操作
        # print(f"函数 '{func.__name__}' 执行完毕")
        
        return result
    
    # 返回包装后的函数（注意要返回wrapper而不是直接调用）
    return wrapper

# 使用装饰器（语法糖写法）
@counter_decorator
def greet(name):
    """
    示例函数：简单的问候函数
    参数：
        name: 要问候的人名
    """
    print(f"你好，{name}！")

# 使用装饰器（等效的原始写法）
# greet = counter_decorator(greet)

# 测试调用
if __name__ == "__main__":
    greet("小明")  # 第1次调用
    greet("小红")  # 第2次调用
    greet()        # 第3次调用（测试无参数情况）
    
    # 输出结果：
    # 函数 'greet' 已被调用 1 次
    # 你好，小明！
    # 函数 'greet' 已被调用 2 次
    # 你好，小红！
    # 函数 'greet' 已被调用 3 次
    # 你好，！  # 注意：无参数时name默认为None，但函数仍正常执行

闭包和装饰器结合的高级用法

def decorator_factory(prefix):  # 外部函数接收参数
    def decorator(func):        # 这是真正的装饰器
        def wrapper(*args, **kwargs):  # 包装函数
            print(f"[{prefix}] 函数 {func.__name__} 开始执行")
            result = func(*args, **kwargs)
            print(f"[{prefix}] 函数 {func.__name__} 执行结束")
            return result
        return wrapper
    return decorator

@decorator_factory("DEBUG")
def example_function(x):
    return x * 2

print(example_function(5))
# 输出:
# [DEBUG] 函数 example_function 开始执行
# [DEBUG] 函数 example_function 执行结束
# 10

6. 为什么要理解这种关系？

  1. 深入理解装饰器：明白装饰器如何工作
  2. 灵活运用：可以自己创建更复杂的装饰器
  3. 调试能力：当装饰器出现问题时知道如何排查
  4. 代码设计：写出更优雅、更Pythonic的代码

7. 总结

  • 所有装饰器都是闭包，但并非所有闭包都是装饰器
  • 装饰器是闭包在函数增强方面的专门应用
  • 理解闭包是掌握装饰器的基础
  • 装饰器通过@语法提供了一种优雅的使用闭包的方式

装饰器和闭包的关系就像"特种兵"和"士兵"的关系——装饰器是闭包在特定领域的专业化应用，具有更明确的目的和更优雅的使用方式。

Python 进阶：闭包与装饰器
m0_59388634的博客
02-10 918
装饰器（Decorator）是一种用于修改或增强函数功能的高级语法。它通过闭包实现，可以在不修改原函数代码的情况下，增加额外的功能。闭包（Closure）是一个函数对象，它能够记住并访问其外层函数中的变量，即使外层函数已经执行完毕。通过这些练习，进一步巩固对闭包和装饰器的理解！
【Python】闭包与装饰器
flylr^的博客
05-11 1917
python中的闭包与装饰器
闭包和装饰器
weixin_58959719的博客
06-07 132
定义： 优点：为变量续命 缺点：浪费内存 装饰器 定义：
python入门（12）——闭包和装饰器
zzhou——blog
04-18 489
文章目录1.闭包1.1 闭包的介绍1.2 闭包的构成条件1.3 简单闭包的示例1.4 闭包的作用1.5 修改闭包内使用的外部变量2.装饰器2.1 装饰器的定义2.2 装饰器的示例代码2.3 装饰器的语法糖写法2.4 装饰带有参数的函数2.5 装饰带有返回值的函数2.6 装饰带有不定长参数的函数2.7 多个装饰器的使用 1.闭包 1.1 闭包的介绍 我们前面已经学过了函数，我们知道当函数调用完，函数...
python基础核心语法-闭包和装饰器
最新发布
m0_52884634的博客
06-03 186
本文介绍了Python中的闭包和装饰器概念。闭包是指内部函数引用外部函数变量的函数结构，需满足：1)函数嵌套；2)内部函数引用外部变量；3)外部函数返回内部函数。装饰器基于闭包实现，是一种特殊闭包，用于在不改变原函数代码的情况下扩展功能。文中通过多个代码示例展示了闭包实现计数器、装饰器计算函数执行时间和调用次数等功能，并比较了两者的异同：装饰器必须接收函数作为参数，而闭包无此限制。同时指出了闭包常见问题（变量作用域和陷阱）及解决方案，以及装饰器的三层嵌套结构实现参数化。
python中的闭包与装饰器
bitcarmanlee的博客
11-20 3803
1.Python中一切皆对象这恐怕是学习Python最有用的一句话。想必你已经知道Python中的list, tuple, dict等内置数据结构，当你执行：alist = [1, 2, 3]时，你就创建了一个列表对象，并且用alist这个变量引用它： 当然你也可以自己定义一个类：class House(object): def __init__(self, area, city):
闭包与装饰器
没枕头我咋睡觉
08-14 158
闭包：在函数内部再定义一个函数，并且这个函数用到了外部函数的一些变量，这个函数以及用到的外部的一些变量合称为闭包。 装饰器：装饰器本身也是一个函数，该函数内部再定义一个函数，并且外部函数的返回值是里面定义的这个函数的引用。 闭包demo def line_conf(a, b): def line(x): return a*x + b return line ...
Python装饰器详解：闭包、多重装饰器与应用实例
理解装饰器的基础是闭包的概念。闭包是指在一个函数内部定义另一个函数，并且内部函数引用了外部函数的变量，这种机制使得内部函数能够访问并操作外部函数的局部状态。 闭包的三个核心要素包括： 1. **内嵌函数**：...
Python高级特性之闭包与装饰器实例详解
09-18
总的来说，闭包和装饰器是Python中强大的工具，它们允许我们在不修改原有代码的基础上增加新的功能或行为，提高了代码的可读性和可维护性。理解和熟练掌握这些概念对于提升Python编程技能至关重要。
深入理解Python：闭包与装饰器实战解析
装饰器和闭包的关系紧密，因为闭包常常被用作装饰器的基础。通过闭包，装饰器可以在不修改原函数主体的情况下，增加额外的逻辑或行为，这类似于化妆和整容的区别——装饰器更倾向于改变函数的外在行为，而闭包则可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值