Python函数式编程入门：闭包与装饰器详解

最新推荐文章于 2025-06-08 07:00:00 发布

慕婉0307

最新推荐文章于 2025-06-08 07:00:00 发布

阅读量794

点赞数 26

分类专栏： python基础知识点文章标签： python 开发语言闭包装饰器

本文链接：https://blog.csdn.net/wyy202206174248/article/details/147853379

版权

python基础知识点专栏收录该内容

27 篇文章

订阅专栏

函数式编程是现代编程范式中的重要组成部分，Python虽然不是纯粹的函数式语言，但提供了强大的函数式编程特性。本文将重点介绍Python中两个核心的函数式编程概念：闭包和装饰器，帮助初学者掌握这些强大工具。

一、函数式编程基础

什么是函数式编程？

函数式编程（Functional Programming）是一种编程范式，它将计算视为数学函数的求值，避免改变状态和使用可变数据。主要特点包括：

函数是一等公民
避免副作用
强调不可变性
使用高阶函数

在编程语言设计中，"一等公民"（First-class Citizen）是指某种语言元素享有与其他元素同等的权利和灵活性。当说"函数是一等公民"时，意味着函数在语言中拥有与其他基本数据类型（如整数、字符串）相同的地位和操作权限。这是函数式编程范式的核心特征之一，也是Python强大灵活性的重要体现。

Python中的函数式特性

# 函数作为一等公民
def greet(name):
    return f"Hello, {name}!"

# 将函数赋值给变量
say_hello = greet
print(say_hello("Alice"))  # 输出: Hello, Alice!

# 函数作为参数
def apply(func, x):
    return func(x)

print(apply(greet, "Bob"))  # 输出: Hello, Bob!

二、闭包（Closure）

闭包的概念

闭包是指一个函数"记住"并"访问"其词法作用域中的变量，即使该函数在其词法作用域之外执行。

闭包必须满足以下三个条件：

必须有一个内嵌函数
内嵌函数必须引用外部函数中变量
外部函数返回值必须是内嵌函数

闭包示例

def outer_func(x):
    def inner_func(y):
        return x + y
    return inner_func

closure = outer_func(10)
print(closure(5))  # 输出: 15

闭包的工作原理

outer_func被调用，创建局部变量x
inner_func被定义并返回，它"记住"了x
即使outer_func执行完毕，inner_func仍能访问x

闭包的实用场景

# 计数器工厂
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

闭包优点

逻辑连续，当闭包作为另一个函数调用参数时，避免脱离当前逻辑而单独编写额外逻辑。
方便调用上下文的局部变量。
加强封装性，是第2点的延伸，可以达到对变量的保护作用。

闭包缺点

引用在，空间不灭：闭包使得函数中的变量保存在内存中，内存消耗很大

三、装饰器（Decorator）

装饰器基础

Python装饰器是一种特殊的高阶函数，它允许在不修改原函数代码的情况下动态增强函数的功能。装饰器本质上是一个接收函数作为参数的可调用对象（通常是一个函数），它返回一个新的函数来"包装"原始函数，通过在函数执行前后添加额外逻辑（如日志记录、性能统计、权限校验等）来实现功能的扩展。使用`@decorator`语法糖可以简洁地将装饰器应用到目标函数上，使得代码更加模块化和可复用，是Python中实现AOP（面向切面编程）的核心技术。

简单装饰器示例

def my_decorator(func):
    def wrapper():
        print("函数执行前")
        func()
        print("函数执行后")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
"""
输出:
函数执行前
Hello!
函数执行后
"""

执行过程：
定义阶段：

当解释器遇到@my_decorator时，会立即执行my_decorator(say_hello)

将原始say_hello函数作为参数传递给my_decorator
装饰过程：
def my_decorator(func):  # func = 原始say_hello
    def wrapper():      # 定义包装函数
        print("函数执行前")  # 新增前置逻辑
        func()          # 调用原始函数
        print("函数执行后")  # 新增后置逻辑
    return wrapper     # 返回包装后的函数
原始say_hello被替换为wrapper函数

现在say_hello变量指向的是wrapper而非原始函数
调用阶段：
say_hello()  # 实际调用的是wrapper()
执行流程：

打印"函数执行前"

调用func()即原始say_hello()，打印"Hello!"

打印"函数执行后"
内存变化示意图：
装饰前: say_hello -> 原始函数对象
装饰后: say_hello -> wrapper函数对象
        wrapper.func -> 原始函数对象（闭包保持引用）
关键点说明：

装饰器在模块导入时就会执行（函数定义时）

实际调用的是被装饰后的新函数

原始函数通过闭包被保留在wrapper的作用域中

这种模式实现了"横切关注点"与核心逻辑的分离

装饰器的工作原理

@my_decorator语法糖等价于：say_hello = my_decorator(say_hello)
调用say_hello()实际上是调用wrapper()
wrapper函数可以访问原始函数func并在其前后添加操作

带参数的装饰器

def repeat(num):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
"""
输出:
Hello, Alice!
Hello, Alice!
Hello, Alice!
"""

四、装饰器的实际应用

1. 计时装饰器

import time

def timer(func):  # 接收被装饰的函数
    def wrapper(*args, **kwargs):  # 定义包装函数
        start = time.time()       # 记录开始时间
        result = func(*args, **kwargs)  # 调用原始函数
        end = time.time()         # 记录结束时间
        print(f"{func.__name__}执行时间: {end-start:.4f}秒")  # 打印耗时
        return result             # 返回原始函数的结果
    return wrapper               # 返回包装后的函数

@timer
def long_running_func():
    time.sleep(2)  # 人为制造一个2秒的"耗时任务" 休眠2s

long_running_func()  # 输出: long_running_func执行时间: 2.0002秒

2. 缓存装饰器

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(30))  # 快速计算结果

3. 权限验证装饰器

def login_required(func):
    def wrapper(user, *args, **kwargs):
        if not user.is_authenticated:
            raise PermissionError("需要登录")
        return func(user, *args, **kwargs)
    return wrapper

@login_required
def view_profile(user):
    print(f"查看{user.username}的个人资料")

五、类装饰器

Python还支持使用类实现装饰器：

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.calls = 0

    def __call__(self, *args, **kwargs):
        self.calls += 1
        print(f"调用次数: {self.calls}")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello():
    print("Hello!")

say_hello()  # 输出: 调用次数: 1 \n Hello!
say_hello()  # 输出: 调用次数: 2 \n Hello!

六、保留函数元信息

使用装饰器时，原始函数的__name__、__doc__等元信息会被覆盖，可以使用functools.wraps来保留：

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """包装函数文档"""
        print("装饰器操作")
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def example():
    """示例函数文档"""
    pass

print(example.__name__)  # 输出: example
print(example.__doc__)   # 输出: 示例函数文档