前言
- 本文是 qbit 对“lambda、闭包、函数式编程、链式调用”等概念的信息收录。
- qbit 对原理认识有限（为什么？）
- qbit 对应用很感兴趣（怎么用？）
- 本文是通俗解释（最好是一句话），不是学术化的精准描述。
- qbit 认为：用高阶函数编程就算是函数式编程。
lambda、头等函数和高阶函数
lambda 表达式
- lambda 表达式就是匿名函数
有没有听着耳熟？在学 C 语言时老师说：指针就是地址
头等函数
- 头等函数（First-class function）
- 相对于“头等函数”，qbit 更喜欢“函数是一等公民”这个说法。
- 在 JavaScript 和 Python 等语言里，函数可以像数值一样使用，比如给变量赋值、作为参数传递给其他函数，作为函数返回值等等。这时，我们就说函数是一等公民。
- 函数作为参数传值时，常写作匿名函数。
高阶函数
- 高阶函数（High-order function）是这样一种函数，它能够接受其他函数作为自己的参数，javascript/python 中数组的 map 方法，就是一个高阶函数。
- 高阶函数要求函数是一等公民。
- 高阶函数编程常常用到匿名函数。
- 高阶函数可以用来做装饰器（Decorator）。
示例
# Python3
>>> f = lambda x: x+1 # 匿名函数作为一等公民给变量赋值
>>> f(7)
8
# 匿名函数作为参数
# map 把其他函数作为自己的参数，是高阶函数
>>> list(map(lambda x: x*2, [1, 2, 3]))
[2, 4, 6]闭包
解释
本节为宫文学《 编译原理之美》的学习笔记
- 实现闭包（Closure）的两个必要条件。
1、函数作为返回值要成为一等公民。
2、要让内层函数一直访问它环境中的变量，不管外层函数退出与否。- 使用闭包时，从形式上来讲有 3 个点：
1、外层函数嵌套内层函数;
2、内层函数要访问外层函数的局部（本地）变量；
3、外层函数 return 内层函数。- 闭包与面向对象类比
1、外层函数就像类（class）
2、外层函数的局部变量就像类的成员变量
3、内层函数就像类的成员函数示例
- js 版（摘自宫文学《编译原理之美》）
/** clojure.js * 测试闭包特性 * 作者：宫文学 */
var a = 0;
var fun1 = function(){
var b = 0; // 函数内的局部变量
var inner = function(){ // 内部的一个函数
a = a+1;
b = b+1;
return b; // 返回内部的成员
}
return inner; // 返回一个函数
}
console.log("outside: a=%d", a);
var fun2 = fun1(); // 生成闭包
for (var i = 0; i< 2; i++){
console.log("fun2: b=%d a=%d",fun2(), a); // 通过fun2()来访问b
}
var fun3 = fun1(); // 生成第二个闭包
for (var i = 0; i< 2; i++){
console.log("fun3: b=%d a=%d",fun3(), a); // b等于1，重新开始
}在 Node.js 环境下运行上面这段代码的结果如下：
outside: a=0
fun2: b=1 a=1
fun2: b=2 a=2
fun3: b=1 a=3
fun3: b=2 a=4
- Python 版（输出和原理与 js 版一致）
# Python3
a = 0
def fun1():
b = 0 # 函数内的局部变量
def inner(): # 内部的一个函数
global a # 声明全局变量
nonlocal b # 声明 inner 外最近外层函数变量
a = a + 1
b = b + 1
return b # 返回内部的成员
return inner # 返回一个函数
print("outside: a=%d" % a)
fun2 = fun1() # 生成闭包（类实例化为对象）
for i in range(0, 2):
print("fun2: b=%d a=%d" % (fun2(), a)) # 通过fun2()来访问b
fun3 = fun1() # 生成第二个闭包
for i in range(0, 2):
print("fun2: b=%d a=%d" % (fun3(), a)) # b等于1，重新开始柯里化
解释
- 在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。
- 这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。
- 所谓"柯里化"，就是把一个多参数的函数，转化为单参数函数。
- 千言不如一例，看下面的例子。
示例
- 用闭包实现柯里化
# Python3
# 普通函数
def Add(x, y):
return x + y
# 柯里化
def CurryAdd(x):
def inner(y):
return x + y
return inner
print(Add(1, 2)) # 3
print(CurryAdd(1)(2)) # 3偏函数
解释
- 这里的偏函数特指 Python3 的 functools.partial
- 当函数的参数个数太多，需要简化时，使用 functools.partial 可以创建一个新的函数，这个新函数可以固定住原函数的部分（partial）参数，从而在调用时更简单。
- 偏函数生成的新函数的参数个数可能是 1 个，也可能是 2个，甚至更多。
- 柯理化是把一个有 n 个参数的函数变成 n 个只有 1 个参数的函数
示例
# Python3
from functools import partial
# 普通函数
def Add(x, y, z):
return x + y + z
# 柯里化
def CurryAdd(x):
def inner1(y):
def inner2(z):
return x + y + z
return inner2
return inner1
# 偏函数
AddBase1 = partial(Add, 1)
print(Add(1, 2, 3)) # 6（普通函数）
print(CurryAdd(1)(2)(3)) # 6（柯里化）
print(AddBase1(2, 3)) # 6（偏函数）装饰器
解释
- 装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
- 装饰器模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
示例
- 装饰器（Decorator）
# Python3
def hello(fn): # hello 是高阶函数
def wrapper():
print("hello, %s" % fn.__name__)
fn()
print("goodbye, %s" % fn.__name__)
return wrapper
@hello
def qbit():
print("i am qbit")
qbit()输出
hello, qbit
i am qbit
goodbye, qbit对于 Python 的这个 @注解语法糖（Syntactic sugar）来说，当你在用某个 @decorator 来修饰某个函数 func 时，如下所示:
@decorator
def func():
pass其解释器会解释成下面这样的语句：
func = decorator(func)函数式编程
解释
- 函数式编程（functional programming）的基础模型来源于 λ 演算。
- qbit 认为：用高阶函数编程就算是函数式编程。
- 函数式编程中的函数这个术语不是指计算机中的函数，而是指数学中的函数，即自变量的映射。
- 函数式编程中的函数只能有一个输入，一个输出。（用柯里化将多个输入参数变成一个）
- 函数式编程三套件：Map、Reduce 和 Filter
示例
- 加法
# Python3
# 普通函数
def Add(x, y):
return x + y
# 函数式编程写法
def CurryAdd(x): # 高阶函数，闭包，柯里化
def inner(y):
return x + y
return inner
print(Add(1, 2)) # 3
print(CurryAdd(1)(2)) # 3- 将数组中正数乘以 2 再求和
命令式编程写法
# Python3
lst = [2, -5, -2, 5, 3, 1, 0, -3]
positive_sum = 0
for i in lst:
if i > 0:
positive_sum += i * 2
print(positive_sum) # 22函数式编程写法
# Python3
from functools import reduce
# 匿名函数作为参数
# map/reduce/filter 把其他函数作为自己的参数，是高阶函数
>>> lst = [2, -5, -2, 5, 3, 1, 0, -3]
>>> reduce(lambda x,y: x+y, map(lambda x: 2*x, filter(lambda x: x>0,lst)))
22链式调用
解释
- 流式接口（fluent interface）是方法论，链式调用（method chaining）是实现方式
- 一般可以把链式调用等同于流式接口
- 链式调用从形式上就是一个点接一个点
- 函数式编程不一定用到链式调用，但链式调用会让函数式编程更优雅。
示例
- js 示例
// 将数组中正数乘以 2 再求和
lst = [2, -5, -2, 5, 3, 1, 0, -3]
sum = lst.filter((x) => {
return x > 0; // 筛正数
}).map((x) => {
return 2 * x; // 乘以2
}).reduce((x, y) => {
return x + y; // 求和
}, 0)
console.log(sum); // 22- Python 实现 filter/map/reduce 链式调用
# Python3
from functools import reduce
class Chain:
def __init__(self, lst):
self.lst = lst
def map(self, fn):
return Chain(map(fn, self.lst))
def filter(self, fn):
return Chain(filter(fn, self.lst))
def reduce(self, fn):
return reduce(fn, self.lst)
# 22
print(Chain([2, -5, -2, 5, 3, 1, 0, -3])
.filter(lambda x: x>0)
.map(lambda x: 2*x)
.reduce(lambda x, y: x+y))本文出自 qbit snap