引言

"函数是Python的一等公民，掌握高阶函数用法，让你的代码从能用蜕变为卓越！"
调研显示，仅15%的Python开发者真正理解闭包和装饰器，而这些技术正是框架开发的核心！本文将用 5个案例，学习这些Python编程技术！

一、闭包（Closure）：函数中的函数

1. 闭包三要素

• 嵌套函数
• 内部函数引用外部变量
• 外部函数返回内部函数

def outer_func(msg):
    # 外层变量
    prefix = "[重要] "
    
    def inner_func():
        # 内层函数访问外层变量
        return prefix + msg
    
    return inner_func  # 返回函数对象

alert = outer_func("系统警告")
print(alert())  # 输出：[重要] 系统警告

真实案例：计数器工厂

def counter_factory(start=0):
    count = start
    
    def counter():
        nonlocal count  # 声明非局部变量
        count += 1
        return count
    
    return counter

# 创建两个独立计数器
c1 = counter_factory(10)
c2 = counter_factory()

print(c1())  # 11
print(c2())  # 1

二、装饰器（Decorator）：不修改源码增强函数

1. 基础装饰器模板

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"开始执行：{func.__name__}")
        result = func(*args, **kwargs)
        print(f"执行结束：{func.__name__}")
        return result
    return wrapper

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

print(add(2, 3))
# 输出：
# 开始执行：add
# 执行结束：add
# 5

2. 带参数的装饰器

def retry(max_attempts):
    def decorator(func):
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    print(f"尝试 {attempts}/{max_attempts} 失败: {e}")
            raise Exception("所有尝试均失败")
        return wrapper
    return decorator

@retry(max_attempts=3)
def call_unstable_api():
    import random
    if random.random() < 0.7:
        raise Exception("API调用失败")
    return "成功"

print(call_unstable_api())

三、lambda：匿名函数的妙用

1. 基础用法

# 传统函数
def square(x):
    return x ** 2

# lambda等效写法
square = lambda x: x ** 2

print(square(5))  # 25

2. 高阶函数搭配

# 数据排序
users = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]
users.sort(key=lambda user: user["age"], reverse=True)

# 过滤数据
numbers = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

真实场景：Pandas数据处理

import pandas as pd

df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
df["C"] = df.apply(lambda row: row["A"] * row["B"], axis=1)

四、三大技术综合实战

案例1：函数执行时间统计器

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} 执行耗时: {elapsed:.6f}秒")
        return result
    return wrapper

@timer
def heavy_computation(n):
    return sum(i * i for i in range(n))

heavy_computation(1000000)

案例2：权限验证装饰器

def require_role(role):
    def decorator(func):
        def wrapper(user, *args, **kwargs):
            if user.get("role") != role:
                raise PermissionError(f"需要 {role} 权限")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

@require_role("admin")
def delete_user(user, user_id):
    return f"用户 {user_id} 已删除"

admin_user = {"name": "Alice", "role": "admin"}
print(delete_user(admin_user, 1001))

案例3：缓存装饰器（闭包应用）

def cache(func):
    _cache = {}
    
    def wrapper(*args):
        if args not in _cache:
            _cache[args] = func(*args)
        return _cache[args]
    
    return wrapper

@cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(50))  # 秒级计算（无缓存需数小时）

五、避坑指南

1. 闭包变量绑定：循环中创建闭包时使用默认参数

#  错误写法
funcs = []
for i in range(3):
    funcs.append(lambda: print(i))  # 全输出2

#  正确写法
funcs = []
for i in range(3):
    funcs.append(lambda i=i: print(i))  # 输出0,1,2

2. 装饰器元信息：使用functools.wraps保留原函数属性

from functools import wraps

def decorator(func):
    @wraps(func)  # 保留原函数名等属性
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

3. lambda过度使用：复杂逻辑仍应使用def

结语

掌握这些高阶函数技术，将可以实现：

写出更模块化的代码
轻松实现AOP编程思想
开发自己的框架和库

实战挑战：

创建一个装饰器，限制函数每秒最多调用3次（限流功能）

欢迎在评论区交流Python编程、开发技巧！

将陆续更新 Python 编程相关的学习资料！

作者：ICodeWR

标签：#编程# #在头条记录我的2025# #春日生活打卡季# #python#