【Python】高阶函数

高阶函数

高阶函数是接受另一个函数作为参数，并返回一个函数作为结果的函数。

这种类型的函数是函数式编程的核心，因为它们允许对行为进行抽象和复用，使得代码更加简洁和灵活。

python 复制代码

def apply_function(func, value):
    return func(value)

def square(x):
    return x * x

print(apply_function(square, 5))  # 输出 25

使用高阶函数实现简易四则运算计算器

python 复制代码

class calculator:
    def apply(self, func, *value):
        return func(*value)
    
    def add(self, *value):
        num = 0
        value_len = len(value)
        for i in range(value_len):
            num = num + value[i]
        
        return num
    
    def sub(self, *value):
        value_len = len(value)
        num = value[0] if (value_len > 0) else 0
        
        for i in range(1, value_len):
            num = num - value[i]
        
        return num
    
    def product(self, *value):
        value_len = len(value)
        num = 1 if (value_len > 0) else 0
        
        for i in range(value_len):
            num = num * value[i]
        
        return num
    
    def division(self, *value):
        value_len = len(value)
        num = value[0] if (value_len > 0) else 0
        
        for i in range(1, value_len):
            num = num / value[i]
        
        return num

cal = calculator()

num_add = cal.apply(cal.add, 1,2,3,4,5)
num_sub = cal.apply(cal.sub, 10,1,1,1,1)
num_pro = cal.apply(cal.product, 10,1,1,1,1)
num_div = cal.apply(cal.division, 10,1,1,1,1)

常用的高阶函数工具：

lambda：
- 功能：创建匿名函数，并返回一个函数对象。
- 语法：lambda arguments: expression
- 参数：
  - arguments：函数的参数，可以是任意数量的参数。
  - expression：函数体，只能是一个表达式，该表达式的结果就是这个匿名函数的返回值。
- 返回值：返回一个函数对象。
- 示例：
  python 复制代码
```
# 定义一个简单的 lambda 表达式作为函数
add = lambda x, y: x + y
# 使用定义的 lambda 函数计算两数之和并打印
print(add(3, 5))  # 输出: 8
```
filter()：
- 功能：应用函数过滤序列，过滤掉不符合条件的元素。
- 语法：filter(function, iterable)
- 参数：
  - function：用来测试元素是否符合条件的函数。
  - iterable：包含需要过滤的元素的可迭代对象。
- 返回值：返回一个迭代器，迭代器中的元素是符合条件的元素。
- 示例：
  python 复制代码
```
nums = [1, 2, 3, 4, 5, 6]
even_nums = filter(lambda x: x % 2 == 0, nums)
print(list(even_nums))  # 输出 [2, 4, 6]
```
map()：
- 功能：用于对序列中的每个元素应用一个给定的函数，并返回一个包含结果的迭代器。
- 语法：map(function, iterable, ...)
- 参数：
  - function：接受一个输入并返回一个值的函数。
  - iterable：一个或多个序列。如果提供了多个序列，则函数应该接受相同数量的参数，每个序列中的元素按顺序配对。
- 返回值：返回一个迭代器，其元素是将输入的序列中的元素传递到函数后得到的结果。
- 示例：
  python 复制代码
```
nums = [1, 2, 3, 4, 5]
squared_nums = map(lambda x: x ** 2, nums)
print(list(squared_nums))  # 输出 [1, 4, 9, 16, 25]
```
reduce()：
- 功能：用于将一个接受两个参数的函数依次地应用到序列的元素上，从而将序列减少为单一的值。
- 语法：reduce(function, iterable[, initializer])
- 参数：
  - function：接受两个参数并返回单个值的函数。
  - iterable：可迭代序列，其元素将被从左到右依次处理。
  - initializer：(可选) 初始值，如果提供，它被放在参与处理的序列的最前面，并在空序列上作为默认值。
- 返回值：返回单一的值，是通过将函数应用于序列的元素累积得到的。
- 示例：
  python 复制代码
```
from functools import reduce

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

result = reduce(lambda x, y: x + y, nums, 2)
print(result)  # 输出 17
```

递归函数

函数可以返回自身来解决问题（函数本身调用自己），这称为递归函数。

python 复制代码

# 计算斐波那契数
def factorial(x):
    if x == 1:
        return 1
    else:
        return x * factorial(x - 1)

if __name__ == '__main__':
    x = factorial(10)
    print(f"The factorial number is {x}")
    
    # The factorial number is 3628800

装饰器

装饰器是一种设计模式，用于修改一个函数、方法或类的行为，而无需直接修改其本身的代码。装饰器在Python中通过高阶函数实现，它接收一个函数作为参数并返回一个新的函数。

python 复制代码

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# 方法一：不使用语法糖 @
def say_hello():
    print("Hello!")
    
hello = my_decorator(say_hello)
hello()

# 方法二：使用语法糖 @
@my_decorator
def say_hello():
    print("Hello!")

say_hello()

闭包

闭包是一个记录了某些函数变量的包裹体，使这些变量即使在函数执行完成后也仍然可访问。闭包常用于封装私有数据。

python 复制代码

def outer_function(msg):
    message = msg

    def inner_function():
        print(message)

    return inner_function

my_func = outer_function('Hello')
my_func()

类型提示

从Python 3.5开始，可以在函数中添加类型提示，提高代码的可读性和可维护性。

python 复制代码

# 参数：字符串类型   返回值：字符串类型
def greet(name: str) -> str:
    return f"Hello {name}"

print(greet("Alice")) # Hello Alice