【Python】高阶函数

高阶函数

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

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

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

def square(x):
    return x * x

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

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

  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)
  

常用的高阶函数工具：

1. lambda：

   • 功能：创建匿名函数，并返回一个函数对象。

   • 语法：lambda arguments: expression

   • 参数：

     • arguments：函数的参数，可以是任意数量的参数。
     • expression：函数体，只能是一个表达式，该表达式的结果就是这个匿名函数的返回值。

   • 返回值：返回一个函数对象。

   • 示例：

     # 定义一个简单的 lambda 表达式作为函数
     add = lambda x, y: x + y
     # 使用定义的 lambda 函数计算两数之和并打印
     print(add(3, 5))  # 输出: 8
     

2. filter()：

   • 功能：应用函数过滤序列，过滤掉不符合条件的元素。

   • 语法：filter(function, iterable)

   • 参数：

     • function：用来测试元素是否符合条件的函数。
     • iterable：包含需要过滤的元素的可迭代对象。

   • 返回值：返回一个迭代器，迭代器中的元素是符合条件的元素。

   • 示例：

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

3. map()：

   • 功能：用于对序列中的每个元素应用一个给定的函数，并返回一个包含结果的迭代器。

   • 语法：map(function, iterable, ...)

   • 参数：

     • function：接受一个输入并返回一个值的函数。
     • iterable：一个或多个序列。如果提供了多个序列，则函数应该接受相同数量的参数，每个序列中的元素按顺序配对。

   • 返回值：返回一个迭代器，其元素是将输入的序列中的元素传递到函数后得到的结果。

   • 示例：

     nums = [1, 2, 3, 4, 5]
     squared_nums = map(lambda x: x ** 2, nums)
     print(list(squared_nums))  # 输出 [1, 4, 9, 16, 25]
     

4. reduce()：

   • 功能：用于将一个接受两个参数的函数依次地应用到序列的元素上，从而将序列减少为单一的值。

   • 语法：reduce(function, iterable[, initializer])

   • 参数：

     • function：接受两个参数并返回单个值的函数。
     • iterable：可迭代序列，其元素将被从左到右依次处理。
     • initializer：(可选) 初始值，如果提供，它被放在参与处理的序列的最前面，并在空序列上作为默认值。

   • 返回值：返回单一的值，是通过将函数应用于序列的元素累积得到的。

   • 示例：

     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
     

递归函数

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

# 计算斐波那契数
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中通过高阶函数实现，它接收一个函数作为参数并返回一个新的函数。

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()

闭包

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

def outer_function(msg):
    message = msg

    def inner_function():
        print(message)

    return inner_function

my_func = outer_function('Hello')
my_func()

类型提示

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

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

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