高阶函数(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」，预填第一个参数
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，让函数支持任意输入输出类型
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. 类型注解支持

#高阶函数的最佳实践

#总结