Python函数式编程风格中包含两种常见的技术：函数式复合和柯里化。本篇文章将分别讲解这两种技术的背景知识、使用方法、实例说明和相应的代码样例。
函数式编程简介
函数式编程是一种编程风格，强调函数对输入的转换过程，与命令式编程的“指令列表”不同。在函数式编程中，函数是“一等公民”，可以作为参数传递、返回值，也可以赋值给变量。这种编程风格特别适合复杂的数学和统计问题。
Python 从 2.2 版本开始，就支持了函数式编程的一些基础功能。Python 3.x 系列还引入了许多新的函数式库和语法，更为方便和优化了函数式编程的使用。
函数式复合(compose)
函数式复合是一种将多个函数组合起来的技术，使得多个函数的调用可以在一行中完成。Python 中可以用 reduce() 函数实现函数式复合。
下面是一段 Python 代码，实现了两个函数的复合：
from functools import reduce
def square(x):
return x ** 2
def add(x, y):
return x + y
f = reduce(lambda x, y: lambda z: x(y(z)), [square, add])
result = f(3, 2)
print(result) # output: 25
首先定义了两个函数 square 和 add。然后使用 reduce() 函数将 square 和 add 函数复合成一个新函数 f。最后使用 f(3, 2) 的形式调用该函数，输出结果为 25。
代码中，Lambda 表达式 lambda x, y: lambda z: x(y(z)) 实现了函数的复合。相当于使用 square(add(x, y)) 或 (x + y) ** 2 的形式来代替 f(x, y)。
函数式复合主要强调了函数的组合，需要使用匿名函数来将多个函数组合成一个。
柯里化(Currying)
柯里化是一种将一个多元函数转化成一列一元函数的技术。Python 中可以用 functools.partial 函数实现柯里化。
下面是一段 Python 代码，实现了一个函数的柯里化：
from functools import partial
def add(x, y):
return x + y
curry_add = partial(add, 3)
result = curry_add(2)
print(result) # output: 5
首先定义了一个二元函数 add。然后使用 partial() 函数将 add 函数柯里化成一个新的函数 curry_add。最后使用 curry_add(2) 的形式调用该函数，输出结果为 5。
代码中，curry_add = partial(add, 3) 将 x 参数设定为常量 3，使得 curry_add(y) 的值等于 add(3, y)。
柯里化技术强调的是函数的应用，通过将原始函数转化为若干个一元函数，可以方便地调用更加通用的模块函数等。
示例说明
下面是两个例子，展示了函数式复合和柯里化的具体使用方法：
示例一：函数式复合
下面是一个完整的示例，展示了如何使用卷积层、池化层和全连接层实现一个深度神经网络：
from functools import reduce
import numpy as np
def convolve(filter_array, input_array):
channel, row_f, col_f = filter_array.shape
channel, row_i, col_i = input_array.shape
output_array = np.zeros((channel, row_i - row_f + 1, col_i - col_f + 1))
for i in range(output_array.shape[0]):
for j in range(output_array.shape[1]):
for k in range(output_array.shape[2]):
output_array[i][j][k] = np.sum(filter_array[i] * input_array[:, j:j + row_f, k:k + col_f])
return output_array
def pooling(input_array, f, stride, mode='max'):
channel, row_i, col_i = input_array.shape
row_f, col_f = f
row_o, col_o = (row_i - row_f) // stride + 1, (col_i - col_f) // stride + 1
output_array = np.zeros((channel, row_o, col_o))
for i in range(row_o):
for j in range(col_o):
output_array[:, i, j] = np.max(input_array[:, i * stride:i * stride + row_f, j * stride:j * stride + col_f], axis=(1, 2)) if mode == 'max' \
else np.mean(input_array[:, i * stride:i * stride + row_f, j * stride:j * stride + col_f], axis=(1, 2))
return output_array
def element_wise_op(array, op):
for i in np.nditer(array, op_flags=['readwrite']):
i[...] = op(i)
def init_weight(filter_shape, method='xavier'):
if method == 'normal':
return np.random.normal(size=filter_shape)
else:
fan_in, fan_out = np.prod(filter_shape[1:]), filter_shape[0] * np.prod(filter_shape[2:])
scale = np.sqrt(6.0 / (fan_in + fan_out))
return np.random.uniform(-scale, scale, size=filter_shape)
def feed_forward(network, x):
# 卷积层和池化层
input_array = x
for layer in network[:-1]:
if layer['layer_type'] == 'conv':
layer['output_array'] = convolve(layer['filters'], input_array)
element_wise_op(layer['output_array'], layer['activator'])
input_array = layer['output_array']
elif layer['layer_type'] == 'pooling':
layer['output_array'] = pooling(input_array, layer['filter_size'], layer['stride'], layer['mode'])
input_array = layer['output_array']
# 全连接层
network[-1]['input_array'] = input_array.reshape(-1, np.prod(input_array.shape))
network[-1]['output_array'] = np.dot(network[-1]['input_array'], network[-1]['weights']) + network[-1]['bias']
element_wise_op(network[-1]['output_array'], network[-1]['activator'])
def init_network():
network = []
input_dim = (3, 32, 32)
# 卷积层1
conv1_filter_num = 32
conv1_filter_size = (5, 5)
conv1_activator = lambda x: max(x, 0)
network.append({'layer_type': 'conv', 'filters': init_weight((conv1_filter_num, input_dim[0], *conv1_filter_size)), 'activator': conv1_activator})
# 池化层1
pooling1_filter_size = (2, 2)
pooling1_stride = 2
pooling1_mode = 'max'
network.append({'layer_type': 'pooling', 'filter_size': pooling1_filter_size, 'stride': pooling1_stride, 'mode': pooling1_mode})
# 卷积层2
conv2_filter_num = 64
conv2_filter_size = (5, 5)
conv2_activator = lambda x: max(x, 0)
network.append({'layer_type': 'conv', 'filters': init_weight((conv2_filter_num, conv1_filter_num, *conv2_filter_size)), 'activator': conv2_activator})
# 池化层2
pooling2_filter_size = (2, 2)
pooling2_stride = 2
pooling2_mode = 'max'
network.append({'layer_type': 'pooling', 'filter_size': pooling2_filter_size, 'stride': pooling2_stride, 'mode': pooling2_mode})
# 全连接层
# 上一层输出的向量长度为 64 * 5 * 5，设定本层神经元个数为 1024
fc1_output_num = 1024
fc1_activator = lambda x: max(x, 0)
network.append({'layer_type': 'fc', 'weights': init_weight((np.prod(network[-2]['output_array'].shape), fc1_output_num)), 'bias': 0.1, 'activator': fc1_activator})
# 输出层
output_num = 10
# 上一层输出为长度为 1024 的向量，本层输出长度为 10
network.append({'layer_type': 'output', 'weights': init_weight((fc1_output_num, output_num)), 'bias': 0.1, 'activator': lambda x: np.exp(x) / np.sum(np.exp(x))})
return network
if __name__ == '__main__':
net = init_network()
x = np.random.uniform(0, 1, (3, 32, 32))
feed_forward(net, x)
上面的代码实现了一个简易的深度神经网络，并使用 Python 函数式编程的方式将卷积层、池化层和全连接层组合在一起。
其中 reduce() 函数用于将函数的输入转化为一列数组，以实现函数的复合。其他部分的代码是神经网络的基本组件，通过函数式编程的方式实现了代码封装和代码复用。
示例二：柯里化
下面是一个完整的示例，展示了如何使用柯里化技术实现各种常用的数学运算：
from functools import partial
# 柯里化的一元函数例子
add = lambda x, y: x + y
add_4 = partial(add, 4)
result = add_4(6) # output: 10
# 柯里化的两元函数例子
multiply = lambda x, y: x * y
double = partial(multiply, 2)
triple = partial(multiply, 3)
result = double(4) # output: 8
result = triple(4) # output: 12
# 柯里化的复杂函数例子
from scipy.optimize import minimize
def objective_function(x, a, b, c):
return a * x ** 2 + b * x + c
a, b, c = 1, 2, 3
partial_f = partial(objective_function, a=a, b=b, c=c)
result = minimize(partial_f, 0).x # output: [-1.]
以上代码展示了柯里化技术常见的三种类型：一元函数、二元函数和复杂函数，以及它们在数学运算中的应用。柯里化技术可以将复杂的多元函数转化为一列更加通用的函数，简化了代码的实现。
总结
本文中，我们介绍了 Python 函数式编程的两种技术：函数式复合和柯里化。函数式复合是将多个函数组合成一个函数的技术，使用 reduce() 函数来实现。而柯里化则是将多元函数转化成一列一元函数的技术，使用 partial() 函数来实现。这两种技术都可以在 Python 中优化代码的实现，提高程序的可维护性和可读性。