22 高阶函数大全

1、高阶函数的定义：

• 接收函数作为参数

• 返回函数作为结果

2、常用内置高阶函数：

• map(func, iterable) - 对每个元素应用函数

  map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

• filter(func, iterable) - 保留返回True的元素

    filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

• reduce(func, iterable) - 累积应用函数

reduce工作原理如下：

1、接收一个二元函数和一个可迭代对象作为参数

2、从左到右依次对序列元素进行累积计算

3、具体过程：

    1.取序列前两个元素，应用函数得到一个结果

    2.将结果与下一个元素继续应用函数

    3.重复上述步骤，直到遍历完整个序列

对于 reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]) 的计算过程：

第1步：1 + 2 = 3

第2步：3 + 3 = 6

第3步：6 + 4 = 10

第4步：10 + 5 = 15

最终返回累积计算的结果 15。

sorted(iterable, key=func) - 自定义排序

• max/min(iterable, key=func) - 自定义最大/最小值

3、自定义高阶函数模式：

• 函数作为参数：def apply(func, data): return func(data)
• 函数作为返回值：def create_func(): return lambda x: x*2
• 装饰器：@decorator语法糖

4、函数式编程技巧：

• 函数组合：compose(f, g)(x) = f(g(x))
• 柯里化：f(a,b,c) → f(a)(b)(c)
• 偏函数：partial(func, arg1) → 固定部分参数

5、实际应用场景

• 数据处理：使用map/filter/reduce处理集合
• 自定义排序：使用sorted的key参数
• 代码复用：使用装饰器添加通用功能
• 延迟执行：返回函数而非立即执行
• 配置与依赖注入：通过高阶函数传递行为

"""
Python高阶函数详解

高阶函数是指能接收函数作为参数或将函数作为返回值的函数。
这是函数式编程的核心概念，使代码更简洁、更模块化、更易于维护。
"""

# 第一部分：高阶函数基本概念
print("=" * 50)
print("第一部分：高阶函数基本概念")
print("=" * 50)

# 1.1 什么是高阶函数
print("\n1.1 什么是高阶函数:")
print("高阶函数是指满足下列条件之一的函数:")
print("1. 接收一个或多个函数作为参数")
print("2. 返回一个函数作为结果")

# 1.2 为什么使用高阶函数
print("\n1.2 为什么使用高阶函数:")
print("- 代码更简洁：减少重复代码")
print("- 更具表达力：专注于做什么，而非怎么做")
print("- 更易于维护：将通用逻辑抽象出来")
print("- 更易于测试：功能模块化")


# 第二部分：Python内置高阶函数
print("\n" + "=" * 50)
print("第二部分：Python内置高阶函数")
print("=" * 50)

# 2.1 map函数
print("\n2.1 map函数:")
# map(function, iterable, ...) - 将函数应用于每个元素并返回结果迭代器

# 示例1：对列表中的每个元素求平方
numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, numbers)  # lambda是匿名函数，这里表示x的平方
print(f"原始列表: {numbers}")
print(f"平方后: {list(squared)}")  # 将map对象转换为列表显示结果

# 示例2：使用多个迭代器
# 使用map函数将两个列表对应位置的元素相加
# lambda x, y: x + y 是一个匿名函数，接收两个参数并返回它们的和
# map会并行遍历list1和list2，对应位置元素进行相加
# 结果是一个map对象，需要转换为列表才能完整显示
list1 = [1, 2, 3]
list2 = [10, 20, 30]
# 将两个列表对应元素相加
added = map(lambda x, y: x + y, list1, list2)
print(f"两个列表: {list1}, {list2}")
print(f"对应元素相加: {list(added)}")  # 结果: [11, 22, 33]

# 2.2 filter函数
print("\n2.2 filter函数:")
# filter(function, iterable) - 过滤出满足条件的元素并返回迭代器

# 示例1：过滤出偶数
# filter的工作原理：
# 1. 接收一个函数和一个可迭代对象作为参数
# 2. 对可迭代对象的每个元素应用该函数
# 3. 返回一个迭代器，包含所有使函数返回True的元素
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 函数返回True的元素会被保留
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(f"原始列表: {numbers}")
print(f"偶数: {list(even_numbers)}")  # 结果: [2, 4, 6, 8, 10]

# 示例2：过滤出非空字符串
strings = ["hello", "", "world", None, "python", ""]
# None和空字符串在布尔上下文中为False
# None和空字符串在布尔上下文中为False
# 使用filter(None, ...)是一种快速过滤假值（False values）的简洁方法
# None作为filter的第一个参数时，会自动过滤掉所有在布尔上下文中为False的元素
# 这包括：
# 1. None
# 2. 空字符串 ""
# 3. 数字0
# 4. 空列表 []
# 5. 空字典 {}
# 6. 空元组 ()
# 等价于 filter(lambda x: bool(x), strings)
# 当 filter() 函数的第一个参数是 None 时，它会自动使用 bool() 函数作为过滤条件，
# 这意味着它将保留那些布尔值为 True 的元素，并移除布尔值为 False 的元素。
non_empty = filter(None, strings)  # 简化写法，直接过滤掉False值
print(f"原始字符串列表: {strings}")
print(f"非空字符串: {list(non_empty)}")  # 结果: ['hello', 'world', 'python']

# 2.3 reduce函数
print("\n2.3 reduce函数:")
# reduce(function, iterable[, initializer]) - 将函数累积应用到序列的元素上
from functools import reduce  # Python 3中需要从functools导入

# 示例1：计算列表元素的和
numbers = [1, 2, 3, 4, 5]
# reduce的工作原理：
# 1、接收一个二元函数和一个可迭代对象作为参数
# 2、从左到右依次对序列元素进行累积计算
# 3、具体过程：
#   取序列前两个元素，应用函数得到一个结果
#   将结果与下一个元素继续应用函数
#   重复上述步骤，直到遍历完整个序列
sum_result = reduce(lambda x, y: x + y, numbers)
print(f"列表: {numbers}")
print(f"元素之和: {sum_result}")  # 结果: 15 (1+2+3+4+5)

# 示例2：使用初始值
# 带初始值10的累加
sum_with_init = reduce(lambda x, y: x + y, numbers, 10)
print(f"带初始值10的累加: {sum_with_init}")  # 结果: 25 (10+1+2+3+4+5)

# 2.4 sorted函数
print("\n2.4 sorted函数:")
# sorted(iterable, key=None, reverse=False) - 返回排序后的新列表

# 示例1：基本排序
numbers = [3, 1, 4, 1, 5, 9, 2]
# sorted函数会返回一个新的列表，而不是修改原列表
sorted_numbers = sorted(numbers)
print(f"原始列表: {numbers}")
print(f"排序后: {sorted_numbers}")  # 结果: [1, 1, 2, 3, 4, 5, 9]

# 示例2：使用key函数自定义排序
words = ["banana", "apple", "cherry", "date"]
# 按照字符串长度排序
sorted_by_length = sorted(words, key=len)  # 使用len函数作为key函数,按照字符串长度排序,
print(f"单词列表: {words}")
print(f"按长度排序: {sorted_by_length}")  # 结果: ['date', 'apple', 'banana', 'cherry']

# 示例3：复杂对象排序
students = [
    {"name": "Alice", "grade": 85},
    {"name": "Bob", "grade": 92},
    {"name": "Charlie", "grade": 78},
]
# 按照grade字段排序
sorted_students = sorted(students, key=lambda student: student["grade"], reverse=True)  # 使用lambda函数作为key函数,按照grade字段排序,降序排列
print("学生按成绩降序排列:")
for student in sorted_students:
    print(f"  {student['name']}: {student['grade']}")

# 2.5 max和min函数
print("\n2.5 max和min函数:")
# max(iterable, *[, key, default]) - 返回最大值
# min(iterable, *[, key, default]) - 返回最小值

# 示例：使用key函数
words = ["apple", "banana", "cherry", "date", "elderberry"]
# 找出最长的单词
longest_word = max(words, key=len)
# 找出最短的单词
shortest_word = min(words, key=len)
print(f"单词列表: {words}")
print(f"最长的单词: {longest_word}")  # 结果: elderberry
print(f"最短的单词: {shortest_word}")  # 结果: date


# 第三部分：自定义高阶函数
print("\n" + "=" * 50)
print("第三部分：自定义高阶函数")
print("=" * 50)

# 3.1 函数作为参数
print("\n3.1 函数作为参数:")


def apply_operation(func, x, y):
    """
    应用一个二元操作函数到两个数上

    参数:
        func: 接收两个参数的函数
        x, y: 要操作的两个数

    返回:
        func(x, y)的结果
    """
    return func(x, y)


# 定义一些操作函数
def add(a, b):
    return a + b


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


# 使用高阶函数
print(f"apply_operation(add, 5, 3): {apply_operation(add, 5, 3)}")  # 结果: 8
print(f"apply_operation(multiply, 5, 3): {apply_operation(multiply, 5, 3)}")  # 结果: 15

# 使用lambda表达式
print(
    f"apply_operation(lambda a, b: a - b, 5, 3): {apply_operation(lambda a, b: a - b, 5, 3)}"
)  # 结果: 2

# 3.2 返回函数的函数
print("\n3.2 返回函数的函数:")


def create_multiplier(factor):
    """
    创建一个乘法器函数

    参数:
        factor: 乘数因子

    返回:
        一个将输入值乘以factor的函数
    """

    # 定义并返回一个新函数
    def multiplier(x):
        return x * factor

    return multiplier  # 返回函数对象，不是调用结果


# 创建特定的乘法器
double = create_multiplier(2)  # 创建一个将输入值乘以2的函数
triple = create_multiplier(3)  # 创建一个将输入值乘以3的函数

# 使用这些函数
print(f"double(5): {double(5)}")  # 结果: 10
print(f"triple(5): {triple(5)}")  # 结果: 15

# 3.3 装饰器 - 高阶函数的典型应用
print("\n3.3 装饰器 - 高阶函数的典型应用:")


def timer_decorator(func):
    """
    一个计时装饰器，记录函数执行时间

    参数:
        func: 要装饰的函数

    返回:
        包装后的函数
    """
    import time

    def wrapper(*args, **kwargs):
        # 记录开始时间
        start_time = time.time()
        # 调用原始函数
        result = func(*args, **kwargs)
        # 计算执行时间
        execution_time = time.time() - start_time
        print(f"函数 {func.__name__} 执行时间: {execution_time:.4f} 秒")
        return result

    return wrapper


# 使用装饰器
@timer_decorator
def slow_function(n):
    """一个故意执行慢的函数"""
    import time

    time.sleep(n)  # 暂停n秒
    return f"完成了{n}秒的工作"


# 调用装饰后的函数
print(slow_function(1))  # 将会输出执行时间


# 第四部分：函数式编程进阶
print("\n" + "=" * 50)
print("第四部分：函数式编程进阶")
print("=" * 50)

# 4.1 函数组合
print("\n4.1 函数组合:")


def compose(f, g):
    """
    组合两个函数: f(g(x))

    参数:
        f, g: 两个函数

    返回:
        一个新函数，表示f和g的组合
    """
    return lambda x: f(g(x))


# 示例函数
def square(x):
    return x * x


def add_one(x):
    return x + 1


# 组合函数
square_then_add_one = compose(add_one, square)  # 先平方再加1
add_one_then_square = compose(square, add_one)  # 先加1再平方

# 测试
print(f"square_then_add_one(3): {square_then_add_one(3)}")  # 结果: 10 (3²+1)
print(f"add_one_then_square(3): {add_one_then_square(3)}")  # 结果: 16 ((3+1)²)

# 4.2 柯里化 (Currying)
print("\n4.2 柯里化 (Currying):")


def curry(func):
    """
    将一个接受多个参数的函数转换为一系列接受单个参数的函数

    参数:
        func: 要柯里化的函数

    返回:
        柯里化后的函数
    """

    def curried(*args):
        if len(args) >= func.__code__.co_argcount:
            return func(*args)
        return lambda *more_args: curried(*(args + more_args))

    return curried


# 定义一个普通的三参数函数
def add_three(a, b, c):
    return a + b + c


# 柯里化这个函数
curried_add = curry(add_three)

# 不同的调用方式
print(f"add_three(1, 2, 3): {add_three(1, 2, 3)}")  # 普通调用: 6
print(f"curried_add(1)(2)(3): {curried_add(1)(2)(3)}")  # 完全柯里化: 6
print(f"curried_add(1, 2)(3): {curried_add(1, 2)(3)}")  # 部分柯里化: 6
print(f"curried_add(1)(2, 3): {curried_add(1)(2, 3)}")  # 部分柯里化: 6

# 4.3 偏函数应用 (Partial Application)
print("\n4.3 偏函数应用 (Partial Application):")
from functools import partial


def power(base, exponent):
    """计算base的exponent次方"""
    return base**exponent


# 创建偏函数
square = partial(power, exponent=2)  # 固定指数为2
cube = partial(power, exponent=3)  # 固定指数为3

# 使用偏函数
print(f"square(4): {square(4)}")  # 结果: 16
print(f"cube(4): {cube(4)}")  # 结果: 64

# 另一个例子：固定第一个参数
power_of_2 = partial(power, 2)  # 固定底数为2
print(f"power_of_2(10): {power_of_2(10)}")  # 结果: 1024 (2^10)


# 总结
print("\n" + "=" * 50)
print("高阶函数总结")
print("=" * 50)

print(
    """
1. 高阶函数核心特点:
   - 接收函数作为参数
   - 返回函数作为结果
   - 使代码更简洁、更模块化

2. Python内置高阶函数:
   - map(): 对迭代器中的每个元素应用函数
   - filter(): 过滤出满足条件的元素
   - reduce(): 累积应用函数到序列元素
   - sorted(): 使用自定义函数排序
   - max()/min(): 使用自定义函数找最大/最小值

3. 自定义高阶函数:
   - 函数作为参数传递
   - 函数作为返回值
   - 装饰器模式

4. 函数式编程进阶:
   - 函数组合: 将多个函数链接起来
   - 柯里化: 将多参数函数转换为单参数函数序列
   - 偏函数: 固定函数的部分参数

5. 最佳实践:
   - 保持函数纯净（无副作用）
   - 使用lambda表达式简化短小函数
   - 组合使用高阶函数构建数据处理管道
   - 使用装饰器分离横切关注点
"""
)

print("\n高阶函数是Python中非常强大的工具，掌握它们可以让你的代码更简洁、更易于维护！")