返回专栏
· 17 分钟阅读

函数式编程


一、什么是函数式编程

函数式编程(Functional Programming,FP)是一种将计算过程视为数学函数求值的编程范式。

它强调使用函数表达计算逻辑,将数据转换、业务规则和程序行为组织为可组合的函数。

与命令式编程主要描述程序如何执行不同,函数式编程更关注表达式之间的计算关系,以及输入数据如何转换为输出结果。

例如,计算一组商品的总价。

命令式实现:

prices = [100, 200, 300]

total = 0
for price in prices:
    total += price

print(total)

程序明确描述了:

  • 创建累加变量。
  • 遍历数据。
  • 修改累加变量。
  • 输出最终结果。

函数式风格实现:

from functools import reduce

prices = [100, 200, 300]

total = reduce(lambda acc, price: acc + price, prices, 0)

print(total)

这里通过函数表达数据归约过程,将列表中的多个值逐步组合为一个结果。

两种方式都能完成计算。函数式编程的核心并不是简单地使用 map、reduce 或 Lambda,而是围绕函数、数据和副作用建立一套更严格的设计方式。

二、函数式编程的核心思想

函数式编程包含多个相互关联的概念。

核心概念 英文名称 主要作用
纯函数 Pure Function 保证相同输入得到相同输出
不可变性 Immutability 避免数据被原地修改
一等函数 First-class Function 将函数作为普通值使用
高阶函数 Higher-order Function 接收或返回其他函数
引用透明性 Referential Transparency 表达式可以被等价结果替换
函数组合 Function Composition 将多个函数组合成更大的计算
声明式编程 Declarative Programming 描述目标和数据转换关系
惰性求值 Lazy Evaluation 在需要时才计算表达式
副作用控制 Side-effect Control 隔离状态修改和外部交互
递归 Recursion 通过函数调用表达重复计算

其中,纯函数、不可变性和副作用控制是理解函数式编程的基础。

三、纯函数(Pure Function)

3.1 纯函数的定义

纯函数是函数式编程最重要的概念之一。

一个函数满足以下两个条件,通常就可以称为纯函数:

  1. 相同的输入始终产生相同的输出。
  2. 执行函数不会产生可观察的副作用。

例如:

def add(a, b):
    return a + b

无论调用多少次:

add(10, 20)
add(10, 20)
add(10, 20)

结果始终为 30。

函数只依赖传入参数,不读取外部可变状态,也不修改外部环境。

3.2 非纯函数

下面是一个依赖外部状态的函数:

counter = 0

def increment():
    global counter
    counter += 1
    return counter

调用:

print(increment())
print(increment())

输出:

1
2

同一个函数在不同时间调用,结果不同。

原因是函数依赖外部变量 counter,并且修改了这个变量。

另一个例子:

import random

def generate_number():
    return random.randint(1, 100)

即使没有修改外部变量,函数也依赖随机数生成器的内部状态,因此不能简单视为纯函数。

3.3 副作用的类型

副作用(Side Effect)是指函数执行过程中,对返回值之外的外部环境产生的可观察影响。

常见副作用包括:

类型 示例
修改外部变量 修改全局变量
修改共享对象 修改传入的列表或字典
文件操作 写入文件、删除文件
网络操作 发送 HTTP 请求
数据库操作 插入、更新、删除数据
日志输出 写入日志系统
随机行为 使用随机数生成器
时间依赖 读取当前时间
异常状态 修改外部系统状态

例如:

def add_item(items, item):
    items.append(item)
    return items

这个函数修改了调用方传入的列表,因此存在副作用。

可以改为创建新列表:

def add_item(items, item):
    return items + [item]

原始列表不会被修改,函数的行为更加容易预测。

3.4 纯函数的优势

纯函数具有以下优势:

可预测性

相同输入产生相同输出,不需要考虑外部状态。

可测试性

不依赖数据库、文件系统或全局变量,单元测试更简单。

可缓存性

对于相同输入,可以缓存计算结果,避免重复计算。

可并行性

纯函数没有共享状态修改带来的竞争问题,更容易安全地并行执行。

可组合性

函数之间的依赖关系清晰,能够构建复杂的计算流程。

需要注意,纯函数并不意味着程序完全不能访问数据库或网络。实际系统通常将纯计算逻辑与外部交互隔离,在系统边界处理副作用。

四、不可变性(Immutability)

4.1 不可变性的定义

不可变性是指一个数据对象创建之后,其状态不再被原地修改。

需要区分:

  • 变量重新绑定。
  • 对象自身状态修改。

例如:

name = "Alice"
name = "Bob"

这里变量 name 被重新绑定到了另一个字符串对象,并不是修改了原字符串。

字符串在 Python 中是不可变对象。

再看列表:

numbers = [1, 2, 3]
numbers.append(4)

这里直接修改了原列表对象,属于可变操作。

4.2 可变与不可变数据

数据类型 Python 中的可变性
int 不可变
float 不可变
str 不可变
tuple 不可变容器
list 可变
dict 可变
set 可变

注意:元组虽然是不可变容器,但如果其中包含列表等可变对象,内部对象仍然可以被修改。

data = (1, [2, 3])

data[1].append(4)

print(data)

输出:

(1, [2, 3, 4])

因此,容器不可变不等于整个对象结构深层不可变。

4.3 不可变数据的处理方式

函数式风格倾向于创建新数据,而不是直接修改原数据。

numbers = [1, 2, 3]

new_numbers = numbers + [4]

print(numbers)
print(new_numbers)

输出:

[1, 2, 3]
[1, 2, 3, 4]

这种方式能够减少多个函数共享同一个可变对象所产生的问题。

4.4 不可变性的优势

  1. 避免意外修改: 数据不会被其他代码随意改变。
  2. 降低状态管理成本: 不需要追踪复杂的修改历史。
  3. 提升并发安全性: 多个线程读取不可变数据通常不需要额外同步。
  4. 方便状态比较: 新旧状态可以独立保存和比较。
  5. 支持时间旅行调试: 保留历史状态,便于回溯问题。

不可变性并不意味着每次都必须复制整个对象。实际语言和运行时可以使用结构共享(Structural Sharing)、持久化数据结构(Persistent Data Structures)等技术,减少复制开销。

五、一等函数(First-class Function)

5.1 什么是一等函数

如果一种编程语言将函数视为一等公民(First-class Citizen),通常意味着函数可以像普通数据一样:

  • 赋值给变量。
  • 作为函数参数传递。
  • 作为函数返回值。
  • 存储在数据结构中。
  • 在运行时创建和使用。

Python、JavaScript、Go、Rust 等语言都支持不同形式的一等函数能力。

5.2 函数赋值给变量

def add(a, b):
    return a + b

operation = add

print(operation(10, 20))

operation 保存了函数对象的引用,可以像原函数一样调用。

5.3 函数作为参数

def calculate(a, b, operation):
    return operation(a, b)

def add(x, y):
    return x + y

def multiply(x, y):
    return x * y

print(calculate(10, 20, add))
print(calculate(10, 20, multiply))

输出:

30
200

calculate 不关心具体执行加法还是乘法,只负责组织计算过程。

5.4 函数作为返回值

def create_multiplier(factor):
    def multiply(value):
        return value * factor

    return multiply

double = create_multiplier(2)
triple = create_multiplier(3)

print(double(10))
print(triple(10))

输出:

20
30

这里 create_multiplier 返回了一个函数对象。

这种能力是高阶函数和闭包的重要基础。

六、高阶函数(Higher-order Function)

6.1 高阶函数的定义

高阶函数是满足以下任意一个条件的函数:

  • 接收一个或多个函数作为参数。
  • 返回一个函数作为结果。

例如:

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

def square(x):
    return x * x

print(apply_twice(square, 2))

执行结果:

16

apply_twice 接收函数 square 作为参数,因此是高阶函数。

6.2 map:映射转换

map 将一个函数应用于可迭代对象中的每个元素,产生转换后的结果。

numbers = [1, 2, 3, 4]

result = map(lambda x: x * 2, numbers)

print(list(result))

输出:

[2, 4, 6, 8]

其计算逻辑可以表示为:

flowchart LR
    A["原始数据"] --> B["逐个读取元素"]
    B --> C["应用转换函数"]
    C --> D["生成转换结果"]
    D --> E["形成结果序列"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

6.3 filter:条件过滤

filter 根据条件函数筛选数据。

numbers = [1, 2, 3, 4, 5, 6]

result = filter(lambda x: x % 2 == 0, numbers)

print(list(result))

输出:

[2, 4, 6]

6.4 reduce:归约计算

reduce 将多个元素逐步归约为一个结果。

from functools import reduce

numbers = [1, 2, 3, 4]

result = reduce(lambda acc, x: acc + x, numbers, 0)

print(result)

输出:

10

归约过程:

flowchart TD
    A["初始累加值:0"] --> B["读取第一个元素:1"]
    B --> C["累加得到:1"]
    C --> D["读取第二个元素:2"]
    D --> E["累加得到:3"]
    E --> F["读取第三个元素:3"]
    F --> G["累加得到:6"]
    G --> H["读取第四个元素:4"]
    H --> I["最终结果:10"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

map、filter 和 reduce 是函数式编程中常见的数据处理工具,但它们并不是函数式编程的全部。

七、函数组合(Function Composition)

7.1 什么是函数组合

函数组合是将多个简单函数连接起来,构建更复杂计算逻辑的过程。

假设存在两个函数:

f(x)=x+10
g(x)=x\times 2

将两个函数组合:

h(x)=g(f(x))

当输入为 5 时:

h(5)=g(15)=30

数学上,函数组合通常表示为:

(g\circ f)(x)=g(f(x))

这里需要注意执行顺序:先执行 f,再执行 g。

7.2 函数组合的代码实现

def add_ten(x):
    return x + 10

def multiply_two(x):
    return x * 2

def compose(f, g):
    return lambda x: g(f(x))

operation = compose(add_ten, multiply_two)

print(operation(5))

输出:

30

组合函数可以进一步抽象:

def compose(*functions):
    def composed(value):
        result = value

        for func in reversed(functions):
            result = func(result)

        return result

    return composed

这里的实现约定参数按从左到右的阅读顺序传入,实际执行时从右向左应用函数。

7.3 函数组合的优势

  • 将复杂业务拆分为多个小函数。
  • 每个函数只负责一个明确的转换。
  • 可以重复使用已有函数。
  • 降低函数之间的依赖。
  • 便于单独测试和调试。

函数组合尤其适合数据处理、文本处理、编译器流水线和请求处理等场景。

八、引用透明性(Referential Transparency)

8.1 什么是引用透明性

如果一个表达式可以被它计算得到的值替换,而不改变程序行为,那么这个表达式具有引用透明性(Referential Transparency)。

例如:

def add(a, b):
    return a + b

result = add(10, 20) * 2

因为 add(10, 20) 始终得到 30,所以可以等价替换为:

result = 30 * 2

程序结果不变。

8.2 引用透明性的价值

引用透明性能够使程序更容易进行:

  • 表达式替换。
  • 代码重构。
  • 结果缓存。
  • 并行计算。
  • 编译器优化。
  • 数学推理。

8.3 引用透明性与纯函数的关系

两者密切相关,但不能简单认为是完全相同的概念。

纯函数强调函数的输入、输出和副作用特征。

引用透明性强调表达式能否被其结果等价替换。

在通常的函数式编程语境下,纯函数调用是实现引用透明性的重要基础。

不过,观察程序行为时还需要明确语义边界。例如,浮点数运算的舍入误差、异常、非终止计算和资源消耗,都可能影响表达式替换是否真正等价。

九、惰性求值(Lazy Evaluation)

9.1 什么是惰性求值

惰性求值是指表达式不会立即计算,而是在结果真正需要时才执行。

与之相对的是严格求值(Strict Evaluation),也称为立即求值。

例如:

numbers = [x * 2 for x in range(1000000)]

列表推导式会立即生成整个列表。

而生成器表达式:

numbers = (x * 2 for x in range(1000000))

不会立即计算所有元素,而是在迭代时逐个生成。

for number in numbers:
    print(number)

9.2 惰性求值的执行过程

flowchart TD
    A["定义计算表达式"] --> B["创建惰性计算对象"]
    B --> C{"是否需要当前结果"}
    C -->|"否"| D["暂不执行计算"]
    D --> C
    C -->|"是"| E["执行对应计算"]
    E --> F["产生当前结果"]
    F --> G{"是否还需要更多结果"}
    G -->|"是"| E
    G -->|"否"| H["结束计算"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

9.3 惰性求值的优势

降低内存占用

不需要一次性保存全部中间结果。

支持无限序列

可以定义理论上无限的数据序列,只在需要时生成元素。

避免无用计算

如果某些结果最终不会被使用,就不必执行对应计算。

构建计算流水线

多个转换操作可以按需串联,避免产生大量中间集合。

9.4 惰性求值的代价

惰性求值并不一定比立即求值更快。

可能带来的问题包括:

  • 计算延迟到使用阶段,错误可能更晚暴露。
  • 同一个惰性表达式可能被重复求值,具体取决于实现。
  • 调试调用链更加复杂。
  • 对外部可变状态的依赖可能导致行为难以预测。
  • 缓存中间结果也可能增加内存消耗。

需要注意,Python 的生成器和迭代器支持按需计算,但 Python 并不是一门采用全面惰性求值策略的语言。

十、递归与函数式编程

递归(Recursion)是函数式编程中常见的控制流程表达方式。

它通过函数调用自身处理规模更小的问题。

10.1 递归的基本结构

递归函数通常包含两个部分:

  1. 基线条件(Base Case):确定递归终止条件。
  2. 递归步骤(Recursive Case):将问题分解为更小的子问题。

例如,计算阶乘:

n!=n\times(n-1)!

基线条件:

0!=1

Python 实现:

def factorial(n):
    if n == 0:
        return 1

    return n * factorial(n - 1)

print(factorial(5))

输出:

120

10.2 递归执行过程

flowchart TD
    A["factorial(5)"] --> B["factorial(4)"]
    B --> C["factorial(3)"]
    C --> D["factorial(2)"]
    D --> E["factorial(1)"]
    E --> F["factorial(0)"]
    F --> G["返回 1"]
    G --> H["返回 1"]
    H --> I["返回 2"]
    I --> J["返回 6"]
    J --> K["返回 24"]
    K --> L["返回 120"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px