Python:函数式编程

函数式编程（Functional Programming, FP）是一种编程范式，强调通过纯函数、不可变数据和声明式风格来构建程序。Python 虽然不是纯函数式语言，但提供了丰富的函数式编程工具。(简单来说是，函数约等于模块功能）

​一、函数式编程的核心原则

1. ​纯函数（Pure Functions）​

   • 相同输入永远得到相同输出。
   • 无副作用（不修改外部状态，如全局变量）。
   • ​示例：add = lambda x, y: x + y 是纯函数。

2. ​不可变数据（Immutable Data）​

   • 数据一旦创建不可修改，任何操作生成新数据。
   • ​示例：Python 的元组（Tuple）是不可变的。

3. ​函数是一等对象（First-Class Functions）​

   • 函数可以像变量一样传递、赋值和返回。
   • ​示例：将函数作为参数传给另一个函数。

4. ​声明式风格（Declarative Style）​

   • 关注“做什么”而非“如何做”（对比命令式编程）。
   • ​示例：用 map 替代 for 循环。

​二、Python 中的函数式工具

1. ​Lambda 函数

• 匿名函数，用于简单操作。
• ​语法：lambda 参数: 表达式
• ​示例：

  square = lambda x: x**2
  print(square(3))  # 输出 9

2. ​高阶函数（Higher-Order Functions）​

• 接收函数作为参数或返回函数的函数。
• ​常用高阶函数：
  • ​map(func, iterable)
    将函数应用到每个元素，返回迭代器。

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

  • ​filter(func, iterable)
    过滤符合条件的元素。

    evens = filter(lambda x: x % 2 == 0, nums)
    print(list(evens))  # [2]

  • ​reduce(func, iterable, initial)
    累积计算结果（需从 functools 导入）。

    from functools import reduce
    sum_all = reduce(lambda acc, x: acc + x, nums, 0)
    print(sum_all)  # 6

3. ​列表推导式与生成器表达式

• ​列表推导式​（替代 map 和 filter）：

  squared = [x**2 for x in nums if x > 1]  # [4, 9]

• ​生成器表达式​（惰性求值，节省内存）：

  gen = (x**2 for x in nums)
  print(next(gen))  # 1

4. ​闭包（Closure）​

• 函数捕获并携带外部作用域的变量。
• ​示例：

  def make_adder(n):
      def adder(x):
          return x + n  # 捕获外部变量 n
      return adder
  
  add5 = make_adder(5)
  print(add5(3))  # 8

5. ​装饰器（Decorators）​

• 修改或增强函数的行为。
• ​示例：记录函数执行时间：

  import time
  
  def timer(func):
      def wrapper(*args, ​**kwargs):
          start = time.time()
          result = func(*args, ​**kwargs)
          end = time.time()
          print(f"{func.__name__} 执行耗时: {end - start:.2f}秒")
          return result
      return wrapper
  
  @timer
  def heavy_computation():
      time.sleep(1)
  
  heavy_computation()  # 输出耗时

​三、函数式编程的进阶工具

1. ​functools 模块

• ​partial：固定函数的部分参数，生成新函数。

  from functools import partial
  add_10 = partial(lambda x, y: x + y, 10)
  print(add_10(5))  # 15

• ​lru_cache：缓存函数结果，优化递归或重复计算。

  from functools import lru_cache
  
  @lru_cache(maxsize=None)
  def fib(n):
      if n < 2:
          return n
      return fib(n-1) + fib(n-2)

2. ​itertools 模块

• 提供高效迭代器工具：

  from itertools import permutations, chain
  
  # 排列组合
  print(list(permutations('AB', 2)))  # [('A','B'), ('B','A')]
  
  # 连接多个可迭代对象
  combined = chain([1, 2], ['a', 'b'])
  print(list(combined))  # [1, 2, 'a', 'b']

​四、函数式编程的典型应用场景

1. ​数据处理流水线

   # 使用 map、filter 和 reduce 处理数据
   data = [1, 2, 3, 4, 5]
   pipeline = reduce(
       lambda acc, x: acc + x,
       map(lambda x: x*2, filter(lambda x: x % 2 == 0, data)),
       0
   )
   print(pipeline)  # (2 * 2 + 4 * 2) = 12

2. ​惰性求值与生成器

   # 处理大型文件时逐行读取
   def read_large_file(file_path):
       with open(file_path) as f:
           for line in f:
               yield line.strip()
   
   lines = read_large_file("data.txt")

3. ​并发与并行

   • 纯函数无副作用，适合多线程/多进程。
   • ​示例：使用 multiprocessing.Pool.map 并行计算。

​五、函数式编程的优缺点

✅ ​优点

• ​简洁性：用更少的代码表达复杂逻辑。
• ​可测试性：纯函数易于单元测试。
• ​可维护性：减少副作用和状态变更。

❌ ​缺点

• ​性能问题：某些场景（如递归）效率低于循环。
• ​学习曲线：需要适应声明式思维。
• ​调试困难：链式调用可能增加调试复杂度。

​六、函数式编程 vs 面向对象编程

​七、学习建议

1. ​从简单开始：先用 map/filter 替代 for 循环。
2. ​理解副作用：尽量编写纯函数。
3. ​掌握工具链：熟练使用 functools 和 itertools。