高阶函数

高阶函数

简而言之，就是可以接受函数作为参数的函数。

基础语法格式：

def f(func):
pass

讲解几个常用的高阶函数：

• sorted函数：排序
• filter函数：过滤
  filter(a,b) a为函数，b是可迭代对象
• map函数
  map(a,b) a为函数，b是可迭代对象

代码示例

Python 3.12.7 (main, Nov  8 2024, 17:55:36) [GCC 14.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> l = ['Java','Python','C++','GO']
>>> sorted(l)
['C++', 'GO', 'Java', 'Python']
>>> l2 = [1,3,6,5,7,2,-1,-6,-3]
>>> sorted(l2)
[-6, -3, -1, 1, 2, 3, 5, 6, 7]
>>> abs(-1)
1
>>> abs(-2)
2
>>> abs(2)
2
>>> abs(0)
0
>>> abs(1)
1
>>> l3 = [2,6,3,-1,-6,-5,-9,0]
>>> sorted(l3,key=abs)
[0, -1, 2, 3, -5, 6, -6, -9]
>>> isinstance(1,int)
True
>>> isinstance(1,float)
False
>>> b = [1,'hello',3.14,abs]
>>> def a(i):
...     if isinstance(i,int):
...         return True
...     else:
...         return False
...
>>> a(b)
False
>>> b
[1, 'hello', 3.14, <built-in function abs>]
>>> filter(a,b)
<filter object at 0x7ff82675fbe0>
>>> list(filter(a,b))
[1]
>>>
>>> b = [1,-2,-8,-9,0,7,6,5]
>>> def a(i):
...     return i**2
...
>>> map(a,b)
<map object at 0x7ff82675fbe0>
>>> list(map(a,b))
[1, 4, 64, 81, 0, 49, 36, 25]
>>>

详解高阶函数(了解)

在 Python 中，高阶函数（Higher-Order Function） 是函数式编程的重要概念。它满足以下至少一个条件：

1. 接受一个或多个函数作为参数
2. 返回一个函数作为结果

Python 中的高阶函数可以显著提升代码的简洁性和复用性。以下是详细解析和示例。

一、高阶函数的核心概念

1. 接受函数作为参数

将函数作为参数传递给其他函数，实现灵活的操作。

示例：

# 定义一个高阶函数
def apply_func(fn, x):
    return fn(x)

# 定义一个普通函数
def square(n):
    return n * n

# 调用高阶函数
result = apply_func(square, 5)
print(result)  # 输出: 25

• apply_func 是一个高阶函数，因为它接收函数 square 作为参数。
• 这种设计允许你动态地切换逻辑（例如替换 square 为其他函数）。

2. 返回函数作为结果

函数可以返回另一个函数，常用于创建闭包或动态生成逻辑。

示例：

# 定义一个高阶函数（闭包）
def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

# 创建具体函数
double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # 输出: 10
print(triple(5))  # 输出: 15

• make_multiplier 是一个高阶函数，返回一个新的函数 multiplier。
• 闭包（Closure）特性使得 multiplier 能记住外部函数 make_multiplier 的参数 factor。

二、Python 内置的高阶函数

1. map(function, iterable)

对可迭代对象的每个元素应用函数，并返回迭代器。

示例：

numbers = [1, 2, 3, 4]
squared = map(lambda x: x ** 2, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16]

特点：

• 返回的是迭代器，需要用 list() 或其他方式转换。

• 支持多个可迭代对象（长度需一致）：

  list1 = [1, 2, 3]
  list2 = [10, 20, 30]
  result = map(lambda x, y: x + y, list1, list2)
  print(list(result))  # 输出: [11, 22, 33]
  

2. filter(function, iterable)

过滤出满足条件的元素（函数返回 True 的项）。

示例：

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出: [2, 4, 6]

特点：

• 如果 function 为 None，会过滤掉所有为 False 的值。

  values = [0, 1, False, True, '', 'hello']
  filtered = filter(None, values)
  print(list(filtered))  # 输出: [1, True, 'hello']
  

3. reduce(function, iterable[, initializer])

对可迭代对象进行累积计算，返回单一结果。

示例：

from functools import reduce

numbers = [1, 2, 3, 4, 5]
total = reduce(lambda x, y: x + y, numbers)
print(total)  # 输出: 15

特点：

• 需要从 functools 模块导入。

• 可指定初始值（initializer）：

  product = reduce(lambda x, y: x * y, numbers, 1)
  print(product)  # 输出: 120
  

4. sorted(iterable, key=None, reverse=False)

对可迭代对象排序，返回新列表。

示例：

words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=lambda s: len(s))
print(sorted_words)  # 输出: ['date', 'apple', 'banana', 'cherry']

特点：

• key 参数指定排序依据（例如字符串长度、数值等）。

三、高阶函数的实际应用场景

1. 数据转换

使用 map() 简化批量操作，例如类型转换或格式化：

str_list = ['1', '2', '3']
int_list = list(map(int, str_list))
print(int_list)  # 输出: [1, 2, 3]

2. 数据过滤

用 filter() 提取符合条件的数据：

nums = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # 输出: [2, 4, 6]

3. 累积计算

用 reduce() 实现聚合操作（如求和、乘积）：

from functools import reduce
numbers = [1, 2, 3, 4, 5]
factorial = reduce(lambda x, y: x * y, numbers)
print(factorial)  # 输出: 120

四、高阶函数的优势

1. 代码简洁性
   • 用 map() 和 filter() 替代循环，减少冗余代码。
2. 复用性
   • 将通用逻辑封装为函数，通过参数传递具体行为。
3. 可读性
   • 函数式风格更符合数学思维，逻辑清晰。

五、注意事项

1. 迭代器惰性求值
   map() 和 filter() 返回的是迭代器，需要显式转换为列表或遍历。
2. 性能优化
   对于大数据量，优先使用生成器（map/filter）而非列表推导式。
3. 避免过度嵌套
   复杂逻辑建议拆分为普通函数，而非依赖多层嵌套的 lambda。

六、总结

高阶函数是 Python 函数式编程的核心工具，结合 map、filter、reduce 和 lambda 可以高效处理数据。掌握这些工具能显著提升代码的优雅性和效率，但需根据场景选择合适的方式（如复杂逻辑使用普通函数而非 lambda）。