Python 高阶函数：让代码飞起来的 “函数式黑科技“

class 卑微码农:
    def __init__(self):
        self.技能 = ['能读懂十年前祖传代码', '擅长用Ctrl+C/V搭建世界', '信奉"能跑就别动"的玄学']
        self.发量 = 100  # 初始发量
        self.咖啡因耐受度 = '极限'
        
    def 修Bug(self, bug):
        try:
            # 试图用玄学解决问题
            if bug.严重程度 == '离谱':
                print("这一定是环境问题！")
            else:
                print("让我看看是谁又没写注释...哦，是我自己。")
        except Exception as e:
            # 如果try块都救不了，那就...
            print("重启一下试试？")
            self.发量 -= 1  # 每解决一个bug，头发-1
 
 
# 实例化一个我
我 = 卑微码农()

引言：当函数成为 "一等公民"

如果你写 Python 时还在重复编写 "遍历列表 - 判断条件 - 处理元素" 的模板代码，那你可能错过了函数式编程的精髓。想象一下：同样是过滤列表中的偶数，普通写法需要 3 行循环，而用高阶函数一行就能搞定；同样是数据转换，高阶函数能让代码从 "东拼西凑" 变得 "行云流水"。

这一切的秘密，就在于 Python 将函数视为 "一等公民"—— 函数可以像变量一样被传递、赋值、作为参数或返回值。而高阶函数（Higher-order Function）正是这一特性的集大成者：它能接收函数作为参数，或返回一个函数，让代码变得更简洁、更灵活、更具表达力。

本文将带你全面解锁 Python 高阶函数的奥秘：从基础概念到内置函数详解，从自定义高阶函数到实战场景落地，用最通俗的语言 + 可运行的代码，让你明白为什么高阶函数是 Python 开发者从 "能用" 到 "精通" 的关键一步。

一、高阶函数基础：函数也能当 "参数" 和 "返回值"

在学习高阶函数之前，我们先明确一个核心概念：在 Python 中，函数是一种特殊的对象。这意味着函数可以像整数、字符串一样，被赋值给变量、作为参数传递、作为返回值返回 —— 这正是高阶函数的理论基础。

1.1 函数作为变量：给函数起个 "别名"

既然函数是对象，那它就可以被赋值给变量。这个看似简单的特性，却是高阶函数的起点。

# 定义一个普通函数
def add(a, b):
    return a + b

# 将函数赋值给变量（注意：不加括号，否则是调用函数）
func = add

# 通过变量调用函数
print(func(2, 3))  # 输出：5
print(func is add)  # 输出：True（func和add指向同一个函数对象）

这里的func就像add的 "别名"，通过func()调用和add()调用完全等效。这个特性告诉我们：函数可以像数据一样被 "传递" 和 "引用"。

1.2 高阶函数的定义：接收函数或返回函数

满足以下任一条件的函数，就是高阶函数：

接收一个或多个函数作为参数；
返回一个函数作为结果。

我们先看一个简单的例子，感受高阶函数如何 "接收函数作为参数"：

# 定义一个高阶函数：接收函数作为参数
def calculator(func, a, b):
    """用传入的函数处理a和b"""
    return func(a, b)

# 定义两个普通函数
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

# 调用高阶函数：传入不同的函数，得到不同的结果
print(calculator(add, 2, 3))      # 输出：5（执行加法）
print(calculator(multiply, 2, 3)) # 输出：6（执行乘法）

这个calculator就是典型的高阶函数：它不关心func具体是加法还是乘法，只负责将参数传递给func并返回结果。这种 "不写死具体逻辑，而是动态传入逻辑" 的方式，正是高阶函数的核心价值 ——解耦逻辑与参数，提升代码复用性。

再看 "返回函数作为结果" 的高阶函数：

# 定义一个高阶函数：返回函数
def make_operation(operator):
    """根据运算符返回对应的处理函数"""
    def add(a, b):
        return a + b
    def subtract(a, b):
        return a - b
    def multiply(a, b):
        return a * b
    
    # 根据输入返回不同的函数
    if operator == "+":
        return add
    elif operator == "-":
        return subtract
    elif operator == "*":
        return multiply
    else:
        raise ValueError("不支持的运算符")

# 调用高阶函数，得到一个具体的函数
add_func = make_operation("+")
sub_func = make_operation("-")

# 使用返回的函数
print(add_func(2, 3))  # 输出：5
print(sub_func(5, 1))  # 输出：4

这里的make_operation根据输入的运算符，返回不同的处理函数。这种 "动态生成函数" 的能力，让代码变得异常灵活 —— 你可以根据运行时的条件，创建不同逻辑的函数。

二、Python 内置高阶函数：一行顶十行的效率神器

Python 内置了多个实用的高阶函数，它们是处理数据的 "瑞士军刀"。掌握这些函数，能让你告别冗长的循环，用一行代码完成复杂的数据处理。

2.1 map ()：批量处理序列元素

map(func, iterable)的作用是：将函数func应用到可迭代对象iterable的每个元素上，返回一个迭代器。简单说，就是 "批量处理元素"。

基本用法：转换数据类型

# 需求：将字符串列表转换为整数列表
str_list = ["1", "2", "3", "4"]

# 普通写法：for循环
int_list = []
for s in str_list:
    int_list.append(int(s))
print(int_list)  # 输出：[1, 2, 3, 4]

# 高阶函数写法：map()
int_iterator = map(int, str_list)  # 返回迭代器
int_list = list(int_iterator)      # 转换为列表
print(int_list)  # 输出：[1, 2, 3, 4]

map(int, str_list)相当于对str_list中的每个元素调用int(s)，批量完成类型转换。

进阶用法：自定义处理函数

当内置函数满足不了需求时，可以传入自定义函数：

# 需求：计算列表中每个数字的平方
num_list = [1, 2, 3, 4, 5]

# 自定义处理函数
def square(x):
    return x **2

# 用map()批量处理
square_iterator = map(square, num_list)
print(list(square_iterator))  # 输出：[1, 4, 9, 16, 25]

处理多参数：传入多个可迭代对象

map还支持传入多个可迭代对象，此时func需要接收对应数量的参数：

# 需求：计算两个列表对应元素的和
list1 = [1, 2, 3]
list2 = [4, 5, 6]

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

# 传入两个可迭代对象
sum_iterator = map(add, list1, list2)
print(list(sum_iterator))  # 输出：[5, 7, 9]

注意：当多个可迭代对象长度不一致时，map会以最短的为准，忽略超出的元素。

2.2 filter ()：筛选序列元素

filter(func, iterable)的作用是：用函数func判断可迭代对象iterable的每个元素，返回所有使func返回True的元素组成的迭代器。简单说，就是 "按条件筛选元素"。

基本用法：筛选符合条件的元素

# 需求：筛选列表中的偶数
num_list = [1, 2, 3, 4, 5, 6]

# 自定义判断函数（返回布尔值）
def is_even(x):
    return x % 2 == 0

# 用filter()筛选
even_iterator = filter(is_even, num_list)
print(list(even_iterator))  # 输出：[2, 4, 6]

filter(is_even, num_list)会遍历num_list，只保留is_even(x)为True的元素。

进阶用法：结合匿名函数

对于简单的判断逻辑，可以用lambda（匿名函数）简化代码：

# 需求：筛选列表中大于3的元素
num_list = [1, 2, 3, 4, 5, 6]

# 用lambda作为判断函数
filtered_iterator = filter(lambda x: x > 3, num_list)
print(list(filtered_iterator))  # 输出：[4, 5, 6]

筛选复杂结构：处理字典列表

# 需求：筛选年龄大于25的用户
users = [
    {"name": "张三", "age": 20},
    {"name": "李四", "age": 30},
    {"name": "王五", "age": 25},
    {"name": "赵六", "age": 35}
]

# 筛选函数
def is_adult(user):
    return user["age"] > 25

# 用filter()筛选
adult_iterator = filter(is_adult, users)
print(list(adult_iterator))
# 输出：[{'name': '李四', 'age': 30}, {'name': '赵六', 'age': 35}]

2.3 reduce ()：累积计算序列元素

reduce(func, iterable[, initial])的作用是：对可迭代对象iterable中的元素，从左到右依次应用函数func进行累积计算。简单说，就是 "把序列缩减为一个值"。

注意：reduce在 Python 3 中被移到了functools模块，使用前需要导入。

基本用法：计算列表元素的总和

from functools import reduce

# 需求：计算列表所有元素的和
num_list = [1, 2, 3, 4, 5]

# 累积函数：接收两个参数，返回它们的累积结果
def add(a, b):
    return a + b

# 用reduce()计算总和
total = reduce(add, num_list)
print(total)  # 输出：15（1+2=3 → 3+3=6 → 6+4=10 → 10+5=15）

计算过程是 "逐步累积" 的：先计算前两个元素的和，再用结果与第三个元素相加，直到遍历完所有元素。

进阶用法：指定初始值

如果提供initial参数，会先将initial与第一个元素计算，再继续后续步骤：

# 计算总和，初始值为10
total_with_initial = reduce(add, num_list, 10)
print(total_with_initial)  # 输出：25（10+1=11 → 11+2=13 → ... → 最终15+10=25）

复杂案例：拼接字符串

# 需求：将字符串列表拼接成一个句子
words = ["Hello", " ", "world", "!"]

# 累积函数：拼接两个字符串
def concat(a, b):
    return a + b

# 用reduce()拼接
sentence = reduce(concat, words)
print(sentence)  # 输出：Hello world!

2.4 sorted ()：灵活排序序列

sorted(iterable, key=None, reverse=False)虽然主要用于排序，但它接收key参数（一个函数），因此也是高阶函数。key函数用于提取每个元素的 "排序键"，决定排序规则。

基本用法：按自然顺序排序

num_list = [3, 1, 4, 1, 5, 9]
print(sorted(num_list))  # 输出：[1, 1, 3, 4, 5, 9]（默认升序）

进阶用法：按自定义规则排序

# 需求：按字符串长度排序
str_list = ["apple", "banana", "cherry", "date"]

# 按长度排序（key=len，用字符串长度作为排序键）
sorted_by_length = sorted(str_list, key=len)
print(sorted_by_length)  # 输出：['date', 'apple', 'banana', 'cherry']

# 倒序排序（reverse=True）
sorted_reverse = sorted(str_list, key=len, reverse=True)
print(sorted_reverse)  # 输出：['banana', 'cherry', 'apple', 'date']

复杂案例：按字典的多个字段排序

# 需求：先按age降序，再按name升序排序用户列表
users = [
    {"name": "张三", "age": 20},
    {"name": "李四", "age": 30},
    {"name": "王五", "age": 25},
    {"name": "赵六", "age": 30}
]

# 自定义key函数：返回元组（-age保证降序，name保证升序）
def sort_key(user):
    return (-user["age"], user["name"])

sorted_users = sorted(users, key=sort_key)
print(sorted_users)
# 输出：
# [{'name': '李四', 'age': 30}, {'name': '赵六', 'age': 30}, 
#  {'name': '王五', 'age': 25}, {'name': '张三', 'age': 20}]

sorted的key参数让排序逻辑变得极其灵活，几乎能满足所有排序需求。

三、自定义高阶函数：打造你的专属 "函数工具"

内置高阶函数虽强，但业务场景千变万化。学会自定义高阶函数，能让你根据实际需求打造更灵活的代码工具。

3.1 函数作为参数：让函数 "按需扩展"

当你需要编写一个 "框架性" 函数，而具体逻辑由使用者决定时，将函数作为参数传入是最佳选择。

案例 1：数据处理框架

def process_data(data, process_func):
    """通用数据处理框架：用process_func处理每个数据"""
    result = []
    for item in data:
        processed_item = process_func(item)
        result.append(processed_item)
    return result

# 用法1：处理整数列表（计算平方）
numbers = [1, 2, 3, 4]
squares = process_data(numbers, lambda x: x** 2)
print(squares)  # 输出：[1, 4, 9, 16]

# 用法2：处理字符串列表（转换为大写）
strings = ["hello", "world"]
uppercase = process_data(strings, lambda s: s.upper())
print(uppercase)  # 输出：['HELLO', 'WORLD']

# 用法3：处理字典列表（提取字段）
users = [{"name": "张三", "age": 20}, {"name": "李四", "age": 30}]
names = process_data(users, lambda u: u["name"])
print(names)  # 输出：['张三', '李四']

process_data本身不包含具体处理逻辑，而是将逻辑通过process_func传入，实现了 "一次编写，多次复用"。

案例 2：带条件的处理函数

def conditional_process(data, condition_func, process_func):
    """仅处理满足条件的元素"""
    result = []
    for item in data:
        if condition_func(item):
            processed = process_func(item)
            result.append(processed)
    return result

# 需求：对列表中大于10的数乘以2
numbers = [5, 12, 8, 15, 3]
processed = conditional_process(
    numbers,
    lambda x: x > 10,  # 条件：大于10
    lambda x: x * 2    # 处理：乘以2
)
print(processed)  # 输出：[24, 30]

这个高阶函数同时接收 "条件函数" 和 "处理函数"，灵活性更高。

3.2 函数作为返回值：动态生成函数

当你需要根据不同条件生成不同逻辑的函数时，让高阶函数返回函数是绝佳方案。

案例 1：生成数学运算函数

def make_math_operation(operator):
    """根据运算符生成对应的运算函数"""
    if operator == "+":
        return lambda a, b: a + b
    elif operator == "-":
        return lambda a, b: a - b
    elif operator == "*":
        return lambda a, b: a * b
    elif operator == "/":
        return lambda a, b: a / b if b != 0 else float("inf")
    else:
        raise ValueError(f"不支持的运算符：{operator}")

# 生成加法函数
add = make_math_operation("+")
print(add(2, 3))  # 输出：5

# 生成除法函数
divide = make_math_operation("/")
print(divide(6, 2))   # 输出：3.0
print(divide(6, 0))   # 输出：inf（避免除零错误）

根据不同的operator，make_math_operation返回不同逻辑的匿名函数，实现了函数的 "动态生成"。

案例 2：带参数的过滤函数生成器

def make_range_filter(min_val, max_val):
    """生成一个筛选指定范围值的函数"""
    def range_filter(x):
        return min_val <= x <= max_val
    return range_filter

# 生成筛选1~10的函数
filter_1_10 = make_range_filter(1, 10)
print(filter_1_10(5))   # 输出：True
print(filter_1_10(11))  # 输出：False

# 结合filter()使用
numbers = [5, 12, 8, 15, 3]
filtered = list(filter(filter_1_10, numbers))
print(filtered)  # 输出：[5, 8, 3]

make_range_filter根据传入的min_val和max_val，生成一个定制化的筛选函数，避免了重复编写类似的判断逻辑。

3.3 装饰器：高阶函数的 "巅峰应用"

装饰器（Decorator）是 Python 中最经典的高阶函数应用 —— 它本质上是一个返回函数的高阶函数，用于在不修改原函数代码的前提下，为函数添加额外功能（如日志、计时、权限校验等）。

基础装饰器：为函数添加日志

def log_decorator(func):
    """为函数添加日志功能的装饰器"""
    def wrapper(*args, **kwargs):
        # 调用原函数前：打印日志
        print(f"调用函数：{func.__name__}，参数：{args}, {kwargs}")
        # 调用原函数
        result = func(*args, **kwargs)
        # 调用原函数后：打印结果
        print(f"函数{func.__name__}返回：{result}")
        return result
    return wrapper

# 使用装饰器（语法糖：@装饰器名）
@log_decorator
def add(a, b):
    return a + b

# 调用被装饰的函数
add(2, 3)
# 输出：
# 调用函数：add，参数：(2, 3), {}
# 函数add返回：5

@log_decorator等价于add = log_decorator(add)：将add函数传入log_decorator，再将返回的wrapper函数赋值给add。这样，调用add(2,3)时，实际执行的是wrapper(2,3)，从而在不修改add代码的情况下添加了日志功能。

带参数的装饰器：定制装饰器行为

如果需要装饰器有参数（如指定日志级别），需要再嵌套一层函数：

def log_decorator(level="INFO"):
    """带参数的日志装饰器：指定日志级别"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] 调用函数：{func.__name__}")
            result = func(*args, **kwargs)
            print(f"[{level}] 函数{func.__name__}执行完毕")
            return result
        return wrapper
    return decorator

# 使用带参数的装饰器
@log_decorator(level="DEBUG")
def multiply(a, b):
    return a * b

multiply(2, 3)
# 输出：
# [DEBUG] 调用函数：multiply
# [DEBUG] 函数multiply执行完毕

带参数的装饰器执行流程是：log_decorator(level="DEBUG")返回decorator函数，再用decorator装饰multiply。

装饰器的实际应用：函数执行计时

import time

def timer_decorator(func):
    """计算函数执行时间的装饰器"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"函数{func.__name__}执行时间：{end_time - start_time:.4f}秒")
        return result
    return wrapper

# 测试一个耗时函数
@timer_decorator
def slow_function(seconds):
    time.sleep(seconds)  # 模拟耗时操作
    return "完成"

slow_function(1)  # 输出：函数slow_function执行时间：1.0012秒

这个装饰器能快速为任何函数添加执行时间统计，在性能优化中非常实用。

四、高阶函数实战：解决实际开发中的 8 大场景

高阶函数不是 "花拳绣腿"，而是能解决实际问题的利器。以下是开发中最常见的 8 个场景，看看高阶函数如何大显身手。

4.1 场景 1：数据清洗与转换

在数据处理中，经常需要批量转换格式、过滤无效数据，map和filter的组合能完美解决。

# 原始数据：包含脏数据的混合列表
raw_data = ["1", "2", "three", "4", None, "5.5", "6"]

# 步骤1：过滤掉非数字字符串和空值
def is_valid_number(s):
    if s is None:
        return False
    # 尝试转换为float，能转换则有效
    try:
        float(s)
        return True
    except ValueError:
        return False

valid_strings = filter(is_valid_number, raw_data)

# 步骤2：将有效字符串转换为float
numbers = map(lambda s: float(s), valid_strings)

# 结果
print(list(numbers))  # 输出：[1.0, 2.0, 4.0, 5.5, 6.0]

用filter筛选有效数据，再用map转换类型，代码比循环更简洁，逻辑更清晰。

4.2 场景 2：列表的复杂排序

sorted的key参数能轻松处理多条件、自定义规则的排序需求。

# 商品列表：需要按"分类>价格（降序）>销量（降序）"排序
products = [
    {"category": "电子", "price": 5000, "sales": 100},
    {"category": "服装", "price": 200, "sales": 500},
    {"category": "电子", "price": 8000, "sales": 50},
    {"category": "服装", "price": 150, "sales": 1000}
]

# 自定义排序键
sorted_products = sorted(
    products,
    key=lambda p: (p["category"], -p["price"], -p["sales"])
)

print(sorted_products)
# 输出：
# [{'category': '服装', 'price': 200, 'sales': 500},
#  {'category': '服装', 'price': 150, 'sales': 1000},
#  {'category': '电子', 'price': 8000, 'sales': 50},
#  {'category': '电子', 'price': 5000, 'sales': 100}]

通过key函数返回的元组，实现了多字段的优先级排序，比手动写比较函数简单 10 倍。

4.3 场景 3：函数复用与逻辑抽象

用高阶函数抽象通用逻辑，避免重复代码。例如，为多个函数添加 "权限校验" 功能。

# 高阶函数：添加权限校验
def require_permission(permission):
    def decorator(func):
        def wrapper(user, *args, **kwargs):
            # 检查用户是否有指定权限
            if permission in user.get("permissions", []):
                return func(user, *args, **kwargs)
            else:
                raise PermissionError(f"用户{user['name']}没有{permission}权限")
        return wrapper
    return decorator

# 业务函数1：删除文章（需要"delete_article"权限）
@require_permission("delete_article")
def delete_article(user, article_id):
    return f"文章{article_id}已删除"

# 业务函数2：发布文章（需要"publish_article"权限）
@require_permission("publish_article")
def publish_article(user, article_id):
    return f"文章{article_id}已发布"

# 测试用户
admin = {"name": "管理员", "permissions": ["delete_article", "publish_article"]}
guest = {"name": "游客", "permissions": []}

print(delete_article(admin, 1))  # 输出：文章1已删除
print(publish_article(admin, 1)) # 输出：文章1已发布

try:
    delete_article(guest, 1)
except PermissionError as e:
    print(e)  # 输出：用户游客没有delete_article权限

用装饰器require_permission为不同业务函数统一添加权限校验，既避免了重复代码，又方便后续修改校验逻辑。

4.4 场景 4：批量函数注册与调用

在框架开发中，常需要注册多个函数并批量调用（如插件机制），高阶函数能简化这一过程。

# 函数注册表
function_registry = []

# 高阶函数：注册函数
def register(func):
    function_registry.append(func)
    return func  # 返回原函数，不改变其行为

# 注册多个函数
@register
def clean_data():
    return "数据清洗完成"

@register
def process_data():
    return "数据处理完成"

@register
def save_data():
    return "数据保存完成"

# 批量调用注册的函数
def run_all():
    results = []
    for func in function_registry:
        results.append(func())
    return results

print(run_all())  # 输出：['数据清洗完成', '数据处理完成', '数据保存完成']

这种模式在 Web 框架的中间件、测试框架的钩子函数中非常常见，通过register装饰器轻松管理需要批量执行的函数。

4.5 场景 5：延迟执行与缓存

有些函数执行代价高（如数据库查询），可以用高阶函数实现缓存，避免重复计算。

def cache_decorator(func):
    """为函数添加缓存功能"""
    cache = {}  # 缓存字典：key=参数，value=返回值
    
    def wrapper(*args):
        # 如果参数在缓存中，直接返回缓存值
        if args in cache:
            print(f"从缓存获取{func.__name__}{args}的结果")
            return cache[args]
        # 否则执行函数并缓存结果
        result = func(*args)
        cache[args] = result
        print(f"计算并缓存{func.__name__}{args}的结果")
        return result
    return wrapper

# 模拟一个耗时的计算函数
@cache_decorator
def expensive_calculation(n):
    print(f"正在计算{n}的平方...")
    time.sleep(1)  # 模拟耗时
    return n **2

# 第一次调用：计算并缓存
print(expensive_calculation(5))  # 输出：正在计算5的平方... 计算并缓存... 25

# 第二次调用：直接从缓存获取
print(expensive_calculation(5))  # 输出：从缓存获取... 25

cache_decorator为函数添加了缓存功能，连续调用相同参数时，直接返回缓存结果，大幅提升性能。

4.6 场景 6：数据聚合与统计

reduce可以灵活实现各种数据聚合操作，如求和、求积、拼接等。

from functools import reduce

# 订单列表：计算总金额
orders = [
    {"product": "手机", "price": 5000, "quantity": 2},
    {"product": "耳机", "price": 500, "quantity": 1},
    {"product": "电脑", "price": 8000, "quantity": 1}
]

# 计算总金额：price * quantity的总和
total_amount = reduce(
    lambda total, order: total + order["price"] * order["quantity"],
    orders,
    0  # 初始值为0
)

print(f"订单总金额：{total_amount}元")  # 输出：订单总金额：18500元

用reduce一行代码实现了复杂的聚合计算，比循环累加更简洁。

4.7 场景 7：函数式编程风格的数据处理管道

将map、filter、reduce等高阶函数组合成 "管道"，实现流式数据处理。

# 数据处理管道：生成数据→过滤→转换→聚合
def data_pipeline():
    # 1. 生成数据（1~10的整数）
    numbers = range(1, 11)
    
    # 2. 过滤：保留偶数
    even_numbers = filter(lambda x: x % 2 == 0, numbers)
    
    # 3. 转换：偶数乘以3
    transformed = map(lambda x: x * 3, even_numbers)
    
    # 4. 聚合：计算总和
    total = reduce(lambda a, b: a + b, transformed)
    
    return total

print(data_pipeline())  # 输出：(2*3)+(4*3)+(6*3)+(8*3)+(10*3) = 6+12+18+24+30 = 90

这种 "管道式" 处理让数据流程一目了然，每个步骤只负责单一职责，便于维护和扩展。

4.8 场景 8：动态生成业务规则

在电商促销、风控规则等场景中，需要动态生成业务规则函数，高阶函数能轻松实现。

def create_promotion_rule(min_amount, discount):
    """生成促销规则：满min_amount减discount"""
    def rule(order_amount):
        if order_amount >= min_amount:
            return order_amount - discount
        return order_amount
    return rule

# 生成不同的促销规则
rule1 = create_promotion_rule(100, 10)   # 满100减10
rule2 = create_promotion_rule(200, 30)   # 满200减30
rule3 = create_promotion_rule(500, 100)  # 满500减100

# 应用规则
print(rule1(150))  # 输出：140（150-10）
print(rule2(180))  # 输出：180（不满200，不减免）
print(rule3(600))  # 输出：500（600-100）

根据业务需求动态生成规则函数，避免了用大量if-else硬编码规则，后期修改或添加规则只需调用create_promotion_rule即可。

五、避坑指南：高阶函数的 6 个常见误区

高阶函数虽然强大，但使用不当容易踩坑。以下是开发者最常遇到的问题及解决方案。

5.1 误区 1：过度使用 lambda，导致代码可读性差

问题：lambda适合简单逻辑，但复杂逻辑用lambda会让代码晦涩难懂。

# 不推荐：复杂逻辑用lambda
result = map(
    lambda x: x** 2 if x % 2 == 0 else x **3,
    [1, 2, 3, 4]
)
print(list(result))  # 输出：[1, 4, 27, 16]

解决方案：复杂逻辑用自定义函数，代码更易读、易调试。

# 推荐：复杂逻辑用自定义函数
def process(x):
    if x % 2 == 0:
        return x** 2
    else:
        return x **3

result = map(process, [1, 2, 3, 4])
print(list(result))  # 输出：[1, 4, 27, 16]

5.2 误区 2：混淆 map/filter 与列表推导式的适用场景

问题：map和filter能做的事，列表推导式也能做，盲目使用会导致代码风格不一致。

# 可以用列表推导式的场景，不必强行用map/filter
numbers = [1, 2, 3, 4]
squares1 = list(map(lambda x: x** 2, numbers))  # 用map
squares2 = [x **2 for x in numbers]             # 列表推导式（更简洁）

解决方案：

简单转换 / 筛选，列表推导式更易读（Python 开发者更熟悉）；
处理大型数据集（需要迭代器节省内存），用map/filter；
已有现成的函数（如int、len），用map更简洁。

5.3 误区 3：忽视 reduce 的性能与可读性问题

问题：reduce虽然强大，但很多场景下用内置函数（如sum、max）更高效、更易读。

from functools import reduce

numbers = [1, 2, 3, 4, 5]

# 不推荐：用reduce计算总和（不如sum直观）
total1 = reduce(lambda a, b: a + b, numbers)

# 推荐：用内置sum函数
total2 = sum(numbers)

解决方案：

求和用sum，求积用math.prod（Python 3.8+），求最大 / 小值用max/min；
只有复杂的累积逻辑（如自定义聚合），才用reduce。

5.4 误区 4：装饰器修改函数元信息，导致调试困难

问题：装饰器返回的wrapper函数会覆盖原函数的元信息（如__name__、__doc__），导致调试时获取错误信息。

def decorator(func):
    def wrapper():
        """wrapper函数的文档字符串"""
        func()
    return wrapper

@decorator
def my_func():
    """my_func的文档字符串"""
    pass

print(my_func.__name__)  # 输出：wrapper（不是my_func）
print(my_func.__doc__)   # 输出：wrapper函数的文档字符串（不是原文档）

解决方案：用functools.wraps保留原函数元信息。

from functools import wraps

def decorator(func):
    @wraps(func)  # 保留原函数元信息
    def wrapper():
        """wrapper函数的文档字符串"""
        func()
    return wrapper

@decorator
def my_func():
    """my_func的文档字符串"""
    pass

print(my_func.__name__)  # 输出：my_func（正确）
print(my_func.__doc__)   # 输出：my_func的文档字符串（正确）

5.5 误区 5：高阶函数嵌套过深，导致代码难以理解

问题：过度嵌套高阶函数（如多层map、filter嵌套），会让代码变成 "一行天书"。

# 不推荐：嵌套过深，可读性差
result = list(map(
    lambda x: x * 2,
    filter(
        lambda x: x > 5,
        map(
            lambda x: x + 3,
            [1, 2, 3, 4, 5]
        )
    )
))
print(result)  # 输出：[16, 18]（计算过程：1+3=4→过滤；...5+3=8→保留→8*2=16）

解决方案：

拆分嵌套，用变量存储中间结果；
或用列表推导式替代多层嵌套。

# 推荐：用列表推导式替代
numbers = [1, 2, 3, 4, 5]
result = [
    (x + 3) * 2
    for x in numbers
    if (x + 3) > 5
]
print(result)  # 输出：[16, 18]

5.6 误区 6：认为高阶函数一定比循环高效

问题：高阶函数的代码更简洁，但不一定比循环高效（尤其是简单逻辑）。

import timeit

# 测试map与循环的效率
setup = "numbers = list(range(10000))"

map_time = timeit.timeit(
    "list(map(lambda x: x*2, numbers))",
    setup=setup,
    number=1000
)

loop_time = timeit.timeit(
    "[x*2 for x in numbers]",
    setup=setup,
    number=1000
)

print(f"map耗时：{map_time:.4f}")    # 约0.3秒
print(f"列表推导式耗时：{loop_time:.4f}")  # 约0.2秒（更高效）

原因：lambda的调用有额外开销，而列表推导式是 Python 优化过的语法，执行效率更高。

解决方案：