高阶函数(Higher-order Function)详解

什么是高阶函数？

先从一个日常开发的小场景说起：

假设你要写一个文件筛选工具：

一开始只筛选「大小 ≥ 10MB」的图片，得写专用函数；

后来要筛选「2023 年之后创建」的文档，又得改代码；

再后来还想筛选「文件名包含 _project」的代码文件……太麻烦了！

如果用高阶函数来解决，你只需写一个通用的筛选框架，把「什么才算合格」这个判断逻辑单独抽成一个函数，作为参数传给框架就好。

回到定义：
高阶函数是一类「能把其他函数当参数」，或者「能返回其他函数当结果」的函数。 它是函数式编程的核心概念，可以帮我们把代码从「写死逻辑」变成「抽离复用 + 灵活组合」。

前置知识：Python 中的「函数是一等公民」

在 Python 里玩转高阶函数的前提是：函数和整数、字符串、列表一样，是「一等公民（First-class Citizen）」，享有三个核心权利：

1. 变量可以「指向」函数

# 取绝对值是内置函数 abs()，直接调用没问题
abs(-20)  # 输出：20

# 我们也可以把 abs 的“使用权”交给变量 f
f = abs
f(-20)    # 输出：20
# 这里的 f 和 abs 指向的是同一个函数对象

2. 函数名本质就是「指向函数的变量」

这一点要格外小心，千万别随便修改内置函数的引用：

# 作死操作：把 abs 变量指向整数 10
abs = 10
abs(-20)  # 直接报错：TypeError: 'int' object is not callable

# （别学！实际开发绝对不要这么做）恢复 abs 的方法
import builtins
abs = builtins.abs
abs(-20)  # 输出：20

⚠️ 重要提醒：在生产代码中，永远不要覆盖内置函数、模块的引用！

第一大特性：函数作为参数

这是我们最常用的高阶函数玩法——把「具体操作」抽成函数，传给「通用流程」。

1. 一个简单的入门例子

def dual_operate(x: int, y: int, op: callable) -> int:
    """通用的「对两个数做同一种操作后合并」的流程"""
    return op(x) + op(y)

# 传入「取绝对值」操作
print(dual_operate(-4, 6, abs))  # 输出：10

# 传入「平方」操作（使用 lambda 更简洁）
print(dual_operate(-4, 6, lambda x: x**2))  # 输出：52

2. Python 内置的三大经典高阶参数函数

① `map()`：批量「变换」数据

它用一个「变换函数」，把可迭代对象（列表、元组等）的每个元素逐个处理，返回一个迭代器（省内存）。

# 场景：把所有数字转成字符串
nums = [1, 3, 5, 7]
str_nums = list(map(str, nums))  # 转为 list 方便打印
print(str_nums)  # 输出：['1', '3', '5', '7']

# 场景：用 lambda 做自定义变换（将两个列表的对应元素相加）
a = [1, 2, 3]
b = [4, 5, 6]
sum_list = list(map(lambda x, y: x + y, a, b))
print(sum_list)  # 输出：[5, 7, 9]

② `filter()`：批量「筛选」数据

用一个「返回 True/False 的判断函数（谓词）」，把符合条件的元素留下来，同样返回迭代器。

# 场景：筛选偶数
nums = [1, 2, 3, 4, 5, 6, 7, 8]
even_nums = list(filter(lambda x: x % 2 == 0, nums))
print(even_nums)  # 输出：[2, 4, 6, 8]

③ `functools.reduce()`：批量「聚合」数据

需要先从 functools 模块导入。它会把可迭代对象的元素逐个叠加处理，最终得到一个结果。

from functools import reduce

# 场景：计算列表的乘积
nums = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, nums)
print(product)  # 输出：120

第二大特性：函数作为返回值

高阶函数不仅能「接收工具」，还能「制造工具」——根据不同的输入，返回不同的定制化函数。

1. 闭包（Closure）：制造「记住上下文」的工具

这里要引入一个概念——闭包：如果返回的内部函数引用了外部函数的变量（哪怕外部函数已经执行完毕），那么这个内部函数就叫闭包。

def create_price_calculator(discount: float):
    """根据不同折扣，制造对应的价格计算器"""
    if not 0 <= discount <= 1:
        raise ValueError("折扣必须在 0 到 1 之间！")
    
    # 内部函数 calculate 会一直记住外部的 discount 变量
    def calculate(original_price: float) -> float:
        return original_price * (1 - discount)
    
    return calculate

# 制造两个不同折扣的计算器
no_discount = create_price_calculator(0.0)
half_price = create_price_calculator(0.5)

print(no_discount(100))  # 输出：100.0
print(half_price(100))  # 输出：50.0

2. 装饰器（Decorator）：制造「给函数加特效」的工具

这是 Python 中最常用、最优雅的闭包 + 高阶函数结合玩法！
它可以在不修改原函数代码的前提下，给函数添加「日志、计时、权限校验」等通用功能。

① 最基础的装饰器

import time

def timer(func: callable) -> callable:
    """给函数加「计时」特效的装饰器"""
    def wrapper(*args, **kwargs):
        # *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 slow_add(a: int, b: int, delay: float = 1.0) -> int:
    time.sleep(delay)
    return a + b

print(slow_add(3, 5))  # 先睡 1 秒，打印耗时，再返回 8

现代 Python 的高阶函数小工具

1. `functools.partial()`：「预填参数」简化调用

如果你有一个函数，但经常要传入固定的某几个参数，可以用 partial() 把它们预填进去，生成一个更简洁的新函数。

from functools import partial
from operator import mul  # 内置的乘法函数，等价于 lambda x, y: x * y

# 场景：经常要算「某个数 × 2」，预填第一个参数 2
double = partial(mul, 2)
print(double(5))  # 输出：10

# 场景：预填第二个参数（使用关键字参数）
square = partial(mul, y=2)
print(square(7))  # 输出：14

2. 类型注解支持

Python 3.5+ 的 typing 模块可以给高阶函数加上规范的类型注解，提升可读性和 IDE 补全体验。

from typing import Callable, TypeVar, List

# 定义通用类型变量 T、U，让函数支持任意输入输出类型
T = TypeVar('T')
U = TypeVar('U')

def my_map(func: Callable[[T], U], iterable: List[T]) -> List[U]:
    """手写一个简化版的 map（返回 list 版），带类型注解"""
    return [func(x) for x in iterable]

# 使用时 IDE 会自动提示类型错误
# 例如将 int 列表转成 str 列表，结果类型是 List[str]
int_list = [1, 2, 3]
str_list = my_map(str, int_list)

高阶函数的最佳实践

参数命名要清晰：如果高阶函数的参数是函数，尽量用 op（操作）、predicate（谓词/判断）、key_func（排序用的键函数）这类有意义的名字，而不是 f、g。
内部逻辑要简单：高阶函数只负责「通用流程」，不要把具体的业务逻辑塞进去，否则就失去了灵活性。
闭包中别随便修改外部变量：如果确实要修改，必须用 nonlocal 关键字（Python 3+）声明，否则会被当作内部函数的局部变量。
性能敏感场景要谨慎：函数调用有一定开销，在大量循环中过度使用高阶函数可能会拖慢速度（例如用列表推导式代替简单的 map / filter 会更快一些）。

总结

高阶函数通过「把函数当一等公民」，实现了代码的抽象、复用、灵活组合：

函数作为参数：可以把「通用流程」和「具体操作」分离；
函数作为返回值：可以制造「记住上下文」或「加特效」的定制化工具；
Python 内置工具：map、filter、functools.reduce、functools.partial、装饰器。

掌握高阶函数是从「Python 入门」到「Python 进阶」的重要一步，能帮你写出更简洁、更优雅、更易维护的代码！

#高阶函数(Higher-order Function)详解

#什么是高阶函数？

#前置知识：Python 中的「函数是一等公民」

#1. 变量可以「指向」函数

#2. 函数名本质就是「指向函数的变量」

#第一大特性：函数作为参数

#1. 一个简单的入门例子

#2. Python 内置的三大经典高阶参数函数

#① map()：批量「变换」数据

#② filter()：批量「筛选」数据

#③ functools.reduce()：批量「聚合」数据

#第二大特性：函数作为返回值

#1. 闭包（Closure）：制造「记住上下文」的工具

#2. 装饰器（Decorator）：制造「给函数加特效」的工具

#① 最基础的装饰器

#现代 Python 的高阶函数小工具

#1. functools.partial()：「预填参数」简化调用

#2. 类型注解支持

#高阶函数的最佳实践

#总结