31函数式编程

函数式编程（Functional Programming）是一种以**函数为核心**的编程范式，强调通过**纯函数的组合**实现逻辑，避免依赖状态和副作用。

与命令式编程（通过变量修改和语句执行流程控制）不同，函数式编程更关注 “做什么” 而非 “怎么做”，其核心思想包括：**函数是一等公民**、**纯函数**、**不可变数据**、**高阶函数**等。

Python 并非纯函数式语言（如 Haskell），但支持函数式编程的核心特性，可灵活结合函数式与命令式风格。

## 核心思想

**1. 函数是 “一等公民”（First-Class Citizens）**

函数与其他数据类型（如整数、字符串）地位平等，可：

- 赋值给变量；
- 作为参数传递给其他函数；
- 作为函数的返回值；
- 存储在数据结构（如列表、字典）中。

```python
# 1. 函数赋值给变量
def add(a, b):
    return a + b

func = add  # 函数赋值给变量
print(func(2, 3))  # 5（通过变量调用函数）

# 2. 函数作为参数
def calculate(func, a, b):
    return func(a, b)

print(calculate(add, 2, 3))  # 5（传递add函数作为参数）

# 3. 函数作为返回值
def make_adder(n):
    def adder(x):
        return x + n
    return adder  # 返回内部函数

add5 = make_adder(5)
print(add5(3))  # 8（调用返回的函数）

# 4. 函数存储在列表中
funcs = [add, lambda x, y: x * y]
print(funcs[0](2, 3))  # 5（调用列表中的函数）
print(funcs[1](2, 3))  # 6
```

输出结果：
```python
5
5
8
5
6
```

**2. 纯函数（Pure Functions）**

纯函数是函数式编程的核心，满足两个条件：

- **无副作用**：不修改函数外部状态（如全局变量、传入参数的引用、I/O 操作等）；
- **确定性**：相同输入始终返回相同输出（输入决定输出，与外部状态无关）。

```python
# 纯函数：无副作用，输入确定则输出确定
def pure_add(a, b):
    return a + b  # 仅依赖输入，不修改外部状态

# 非纯函数1：修改全局变量（副作用）
global_num = 10
def impure_add1(x):
    global global_num
    global_num += x  # 修改全局变量（副作用）
    return global_num

# 非纯函数2：修改传入参数（副作用）
def impure_add2(lst, x):
    lst.append(x)  # 修改输入列表（副作用）
    return lst

# 非纯函数3：结果依赖外部状态（非确定性）
import random
def impure_random(x):
    return x + random.randint(1, 10)  # 结果不确定（依赖随机数）
```

优势：

- 可测试性：无需模拟外部状态，输入固定即可验证输出；
- 可缓存性：相同输入结果固定，可通过缓存（如functools.lru_cache）优化性能；
- 线程安全：无共享状态修改，适合并行计算；
- 可读性：逻辑独立，无需关注外部状态变化。

**3. 不可变数据（Immutable Data）**

函数式编程强调**数据不可变**：一旦创建，数据不能被修改，只能通过函数生成新数据。这避免了因状态变化导致的副作用，使代码更可预测。

Python 中部分内置类型是不可变的（如int、str、tuple、frozenset），可变类型（如list、dict）需通过特殊处理实现不可变性：

```python
# 不可变类型：修改时生成新对象
s = "hello"
s2 = s.upper()  # 生成新字符串"HELLO"，原s不变
print(s)  # "hello"（原数据未变）

t = (1, 2, 3)
t2 = t + (4,)  # 生成新元组(1,2,3,4)，原t不变

# 处理可变类型：避免直接修改，返回新对象
def add_to_list(lst, x):
    # 不修改原列表，返回新列表（纯函数）
    return lst + [x]  # 或lst.copy()后append

original = [1, 2]
new_list = add_to_list(original, 3)
print(original)  # [1, 2]（原列表未变）
print(new_list)  # [1, 2, 3]（新列表）
```

输出结果：

```python
hello
[1, 2]
[1, 2, 3]
```

**4. 高阶函数（Higher-Order Functions）**

接收函数作为参数，或返回函数的函数称为高阶函数。高阶函数是函数式编程中组合逻辑的核心工具，Python 内置了多个常用高阶函数：

（1）map(func, iterable)：对可迭代对象的每个元素应用func，返回迭代器

功能：将函数func映射到iterable的每个元素，等价于(func(x) for x in iterable)。

```python
numbers = [1, 2, 3, 4]
str_numbers = map(str, numbers)  # 返回迭代器
print(list(str_numbers))  # ['1', '2', '3', '4']
```

（2）filter(func, iterable)：筛选出func(x)为True的元素，返回迭代器

功能：保留iterable中使func(x)为真的元素，等价于(x for x in iterable if func(x))。

```python
numbers = [1, 2, 3, 4, 5, 6]
evens = filter(lambda x: x % 2 == 0, numbers)
print(list(evens))  # [2, 4, 6]
```

（3）functools.reduce(func, iterable[, initial])：累积计算可迭代对象

功能：通过func对iterable进行累积操作（如求和、求积），func需接收两个参数（上一次结果和当前元素）。

```python
from functools import reduce

numbers = [1, 2, 3, 4]
total = reduce(lambda x, y: x + y, numbers)  # 等价于1+2=3 → 3+3=6 → 6+4=10
print(total)  # 10

# 带初始值（initial=10）：10+1=11 → 11+2=13 → 13+3=16 → 16+4=20
total_with_initial = reduce(lambda x, y: x + y, numbers, 10)
print(total_with_initial)  # 20
```

（4）自定义高阶函数

除内置函数外，可自定义高阶函数实现逻辑复用：

```python
def with_log(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数：{func.__name__}，参数：{args}, {kwargs}")
        result = func(*args, **kwargs)
        print(f"函数{func.__name__}返回：{result}")
        return result
    return wrapper

# 使用高阶函数包装add
@with_log  # 等价于 add = with_log(add)
def add(a, b):
    return a + b

add(2, 3)
# 输出：
# 调用函数：add，参数：(2, 3), {}
# 函数add返回：5
```

**5. 匿名函数（lambda）**

lambda用于创建简单的匿名函数，语法：lambda 参数: 表达式（返回表达式结果）。

适合定义简短的函数作为参数传递（如map、filter的第一个参数）。

```python
# 用lambda定义加法函数
add = lambda a, b: a + b
print(add(2, 3))  # 5

# 与map配合：计算列表元素的平方
numbers = [1, 2, 3]
squares = map(lambda x: x**2, numbers)
print(list(squares))  # [1, 4, 9]
```

**注意**：lambda仅适合简单逻辑（单表达式），复杂逻辑应使用def定义命名函数。

**6. 递归（Recursion）**

函数式编程中常用递归替代循环（避免状态修改），即函数调用自身解决问题。递归需满足：

- 终止条件（避免无限递归）；
- 问题规模逐步缩小。

```python
def factorial(n):
    if n == 0:  # 终止条件
        return 1
    return n * factorial(n - 1)  # 递归调用（规模缩小）

print(factorial(5))  # 120（5×4×3×2×1）
```

**Python 中的限制**：Python 默认递归深度约为 1000，超过会抛出RecursionError。如需处理深层递归，可通过sys.setrecursionlimit()调整（但不推荐，大规模递归建议用循环或尾递归优化，Python 对尾递归无原生优化）。

## 适用场景

1.数据处理与转换：如日志分析、数据清洗（map/filter/reduce擅长此类操作）；

2.并行计算：纯函数无状态，适合多进程 / 多线程任务；

3.配置式逻辑：通过函数组合动态构建业务逻辑（如规则引擎）；

4.*缓存与优化：利用lru_cache缓存纯函数结果，提升重复计算性能。