函数式编程

函数式编程

当我们说起函数式编程来说,我们会看到如下函数式编程的长相:

  • 函数式编程的三大特性:
    • immutable data 不可变数据:像Clojure一样,默认上变量是不可变的,如果你要改变变量,你需要把变量copy出去修改。这样一来,可以让你的程序少很多Bug。因为,程序中的状态不好维护,在并发的时候更不好维护。(你可以试想一下如果你的程序有个复杂的状态,当以后别人改你代码的时候,是很容易出bug的,在并行中这样的问题就更多了)
    • first class functions:这个技术可以让你的函数就像变量一样来使用。也就是说,你的函数可以像变量一样被创建,修改,并当成变量一样传递,返回或是在函数中嵌套函数。这个有点像Javascript的Prototype(参看Javascript的面向对象编程
    • 尾递归优化:我们知道递归的害处,那就是如果递归很深的话,stack受不了,并会导致性能大幅度下降。所以,我们使用尾递归优化技术——每次递归时都会重用stack,这样一来能够提升性能,当然,这需要语言或编译器的支持。Python就不支持。
  • 函数式编程的几个技术
    • map & reduce :这个技术不用多说了,函数式编程最常见的技术就是对一个集合做Map和Reduce操作。这比起过程式的语言来说,在代码上要更容易阅读。(传统过程式的语言需要使用for/while循环,然后在各种变量中把数据倒过来倒过去的)这个很像C++中的STL中的foreach,find_if,count_if之流的函数的玩法。
    • pipeline:这个技术的意思是,把函数实例成一个一个的action,然后,把一组action放到一个数组或是列表中,然后把数据传给这个action list,数据就像一个pipeline一样顺序地被各个函数所操作,最终得到我们想要的结果。
    • recursing 递归 :递归最大的好处就简化代码,他可以把一个复杂的问题用很简单的代码描述出来。注意:递归的精髓是描述问题,而这正是函数式编程的精髓。
    • currying:把一个函数的多个参数分解成多个函数, 然后把函数多层封装起来,每层函数都返回一个函数去接收下一个参数这样,可以简化函数的多个参数。在C++中,这个很像STL中的bind_1st或是bind2nd。
    • higher order function 高阶函数:所谓高阶函数就是函数当参数,把传入的函数做一个封装,然后返回这个封装函数。现象上就是函数传进传出,就像面向对象对象满天飞一样。

  • 还有函数式的一些好处
    • parallelization 并行:所谓并行的意思就是在并行环境下,各个线程之间不需要同步或互斥。
    • lazy evaluation 惰性求值:这个需要编译器的支持。表达式不在它被绑定到变量之后就立即求值,而是在该值被取用的时候求值,也就是说,语句如x:=expression; (把一个表达式的结果赋值给一个变量)明显的调用这个表达式被计算并把结果放置到 x 中,但是先不管实际在 x 中的是什么,直到通过后面的表达式中到 x 的引用而有了对它的值的需求的时候,而后面表达式自身的求值也可以被延迟,最终为了生成让外界看到的某个符号而计算这个快速增长的依赖树。
    • determinism 确定性:所谓确定性的意思就是像数学那样 f(x) = y ,这个函数无论在什么场景下,都会得到同样的结果,这个我们称之为函数的确定性。而不是像程序中的很多函数那样,同一个参数,却会在不同的场景下计算出不同的结果。所谓不同的场景的意思就是我们的函数会根据一些运行中的状态信息的不同而发生变化。

上面的那些东西太抽象了,还是让我们来循序渐近地看一些例子吧。

我们先用一个最简单的例子来说明一下什么是函数式编程。

先看一个非函数式的例子:

int cnt;
void increment(){
    cnt++;
}

那么,函数式的应该怎么写呢?

int increment(int cnt){
    return cnt+1;
}

你可能会觉得这个例子太普通了。是的,这个例子就是函数式编程的准则:不依赖于外部的数据,而且也不改变外部数据的值,而是返回一个新的值给你

我们再来看一个简单例子:

def inc(x):
    def incx(y):
        return x+y
    return incx

inc2 = inc(2)
inc5 = inc(5)

print inc2(5) # 输出 7
print inc5(5) # 输出 10

我们可以看到上面那个例子inc()函数返回了另一个函数incx(),于是我们可以用inc()函数来构造各种版本的inc函数,比如:inc2()和inc5()。这个技术其实就是上面所说的Currying技术。从这个技术上,你可能体会到函数式编程的理念:把函数当成变量来用,关注于描述问题而不是怎么实现,这样可以让代码更易读。

Map & Reduce

在函数式编程中,我们不应该用循环迭代的方式,我们应该用更为高级的方法,如下所示的Python代码

 name_len = map(len, ["hao", "chen", "coolshell"])
print name_len
# 输出 [3, 4, 9] 

你可以看到这样的代码很易读,因为,这样的代码是在描述要干什么,而不是怎么干

我们再来看一个Python代码的例子:

def toUpper(item):
      return item.upper()

upper_name = map(toUpper, ["hao", "chen", "coolshell"])
print upper_name
# 输出 ['HAO', 'CHEN', 'COOLSHELL']

顺便说一下,上面的例子个是不是和我们的STL的transform有些像?

#include <iostream>
#include <algorithm>
#include <string>
using namespace std;

int main() {
  string s="hello";
  string out;
  transform(s.begin(), s.end(), back_inserter(out), ::toupper);
  cout << out << endl;
  // 输出:HELLO
}

在上面Python的那个例子中我们可以看到,我们写义了一个函数toUpper,这个函数没有改变传进来的值,只是把传进来的值做个简单的操作,然后返回。然后,我们把其用在map函数中,就可以很清楚地描述出我们想要干什么。而不会去理解一个在循环中的怎么实现的代码,最终在读了很多循环的逻辑后才发现原来是这个或那个意思。 下面,我们看看描述实现方法的过程式编程是怎么玩的(看上去是不是不如函数式的清晰?):

upname =['HAO', 'CHEN', 'COOLSHELL']
lowname =[] 
for i in range(len(upname)):
    lowname.append( upname[i].lower() )

对于map我们别忘了lambda表达式:你可以简单地理解为这是一个inline的匿名函数。下面的lambda表达式相当于:def func(x): return x*x

squares = map(lambda x: x * x, range(9))
print squares
# 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64]

我们再来看看reduce怎么玩?(下面的lambda表达式中有两个参数,也就是说每次从列表中取两个值,计算结果后把这个值再放回去,下面的表达式相当于:((((1+2)+3)+4)+5) )

print reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
# 输出 15

Python中的除了map和reduce外,还有一些别的如filter, find, all, any的函数做辅助(其它函数式的语言也有),可以让你的代码更简洁,更易读。 我们再来看一个比较复杂的例子:

num =[2, -5, 9, 7, -2, 5, 3, 1, 0, -3, 8]
positive_num_cnt = 0
positive_num_sum = 0
for i in range(len(num)):
    if num[i] > 0:
        positive_num_cnt += 1
        positive_num_sum += num[i]

if positive_num_cnt > 0:
    average = positive_num_sum / positive_num_cnt

print average
# 输出 5

如果用函数式编程,这个例子可以写成这样:

positive_num = filter(lambda x: x>0, num)
average = reduce(lambda x,y: x+y, positive_num) / len( positive_num )

C++11玩的法:

#include <iostream>
#include <algorithm>
#include <numeric>
#include <string>
#include <vector>
using namespace std;

vector num {2, -5, 9, 7, -2, 5, 3, 1, 0, -3, 8};
vector p_num;
copy_if(num.begin(), num.end(), back_inserter(p_num), [](int i){ return (i>0);} );
int average = accumulate(p_num.begin(), p_num.end(), 0) / p_num.size();
cout << "averge: " << average << endl;

我们可以看到,函数式编程有如下好处:

1)代码更简单了。
2)数据集,操作,返回值都放到了一起。
3)你在读代码的时候,没有了循环体,于是就可以少了些临时变量,以及变量倒来倒去逻辑。
4)你的代码变成了在描述你要干什么,而不是怎么去干。

最后,我们来看一下Map/Reduce这样的函数是怎么来实现的(下面是Javascript代码)

var map = function (mappingFunction, list) {
  var result = [];
  forEach(list, function (item) {
    result.push(mappingFunction(item));
  });
  return result;
};

下面是reduce函数的javascript实现(谢谢 @下雨在家 修正的我原来的简单版本)

function reduce(actionFunction, list, initial){
    var accumulate;
    var temp;
    if(initial){
        accumulate = initial;
    }
    else{
        accumulate = list.shfit();
    }
    temp = list.shift();
    while(temp){
        accumulate = actionFunction(accumulate,temp);
        temp = list.shift();
    }
    return accumulate;
};

Declarative Programming vs Imperative Programming

前面提到过多次的函数式编程关注的是:describe what to do, rather than how to do it. 于是,我们把以前的过程式的编程范式叫做 Imperative Programming – 指令式编程,而把函数式的这种范式叫做 Declarative Programming – 声明式编程。

下面我们看一下相关的示例(本示例来自这篇文章 )。

比如,我们有3辆车比赛,简单起见,我们分别给这3辆车有70%的概率可以往前走一步,一共有5次机会,我们打出每一次这3辆车的前行状态。

对于Imperative Programming来说,代码如下(Python):

from random import random

time = 5
car_positions = [1, 1, 1]

while time:
    # decrease time
    time -= 1

    print ''
    for i in range(len(car_positions)):
        # move car
        if random() > 0.3:
            car_positions[i] += 1

        # draw car
        print '-' * car_positions[i]

我们可以把这个两重循环变成一些函数模块,这样有利于我们更容易地阅读代码:

from random import random

def move_cars():
    for i, _ in enumerate(car_positions):
        if random() > 0.3:
            car_positions[i] += 1

def draw_car(car_position):
    print '-' * car_position

def run_step_of_race():
    global time
    time -= 1
    move_cars()

def draw():
    print ''
    for car_position in car_positions:
        draw_car(car_position)

time = 5
car_positions = [1, 1, 1]

while time:
    run_step_of_race()
    draw()

上面的代码,我们可以从主循环开始,我们可以很清楚地看到程序的主干,因为我们把程序的逻辑分成了几个函数,这样一来,我们的代码逻辑也会变得几个小碎片,于是我们读代码时要考虑的上下文就少了很多,阅读代码也会更容易。不像第一个示例,如果没有注释和说明,你还是需要花些时间理解一下。而把代码逻辑封装成了函数后,我们就相当于给每个相对独立的程序逻辑取了个名字,于是代码成了自解释的

但是,你会发现,封装成函数后,这些函数都会依赖于共享的变量来同步其状态。于是,我们在读代码的过程时,每当我们进入到函数里,一量读到访问了一个外部的变量,我们马上要去查看这个变量的上下文,然后还要在大脑里推演这个变量的状态, 我们才知道程序的真正逻辑。也就是说,这些函数间必需知道其它函数是怎么修改它们之间的共享变量的,所以,这些函数是有状态的

我们知道,有状态并不是一件很好的事情,无论是对代码重用,还是对代码的并行来说,都是有副作用的。因此,我们要想个方法把这些状态搞掉,于是出现了我们的 Functional Programming 的编程范式。下面,我们来看看函数式的方式应该怎么写?

from random import random

def move_cars(car_positions):
    return map(lambda x: x + 1 if random() > 0.3 else x,
               car_positions)

def output_car(car_position):
    return '-' * car_position

def run_step_of_race(state):
    return {'time': state['time'] - 1,
            'car_positions': move_cars(state['car_positions'])}

def draw(state):
    print ''
    print '\n'.join(map(output_car, state['car_positions']))

def race(state):
    draw(state)
    if state['time']:
        race(run_step_of_race(state))

race({'time': 5,
      'car_positions': [1, 1, 1]})

上面的代码依然把程序的逻辑分成了函数,不过这些函数都是functional的。因为它们有三个症状:

1)它们之间没有共享的变量。
2)函数间通过参数和返回值来传递数据。
3)在函数里没有临时变量。

我们还可以看到,for循环被递归取代了(见race函数)—— 递归是函数式编程中带用到的技术,正如前面所说的,递归的本质就是描述问题是什么。

Pipeline

pipeline 管道借鉴于Unix Shell的管道操作——把若干个命令串起来,前面命令的输出成为后面命令的输入,如此完成一个流式计算。(注:管道绝对是一个伟大的发明,他的设哲学就是KISS – 让每个功能就做一件事,并把这件事做到极致,软件或程序的拼装会变得更为简单和直观。这个设计理念影响非常深远,包括今天的Web Service,云计算,以及大数据的流式计算等等)

比如,我们如下的shell命令:

ps auwwx | awk '{print $2}' | sort -n | xargs echo

如果我们抽象成函数式的语言,就像下面这样:

xargs(  echo, sort(n, awk('print $2', ps(auwwx)))  )

也可以类似下面这个样子:

pids = for_each(result, [ps_auwwx, awk_p2, sort_n, xargs_echo]) 

好了,让我们来看看函数式编程的Pipeline怎么玩?

我们先来看一个如下的程序,这个程序的process()有三个步骤:

1)找出偶数。
2)乘以3
3)转成字符串返回

def process(num):
    # filter out non-evens
    if num % 2 != 0:
        return
    num = num * 3
    num = 'The Number: %s' % num
    return num

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for num in nums:
    print process(num)

# 输出:
# None
# The Number: 6
# None
# The Number: 12
# None
# The Number: 18
# None
# The Number: 24
# None
# The Number: 30

我们可以看到,输出的并不够完美,另外,代码阅读上如果没有注释,你也会比较晕。下面,我们来看看函数式的pipeline(第一种方式)应该怎么写?

def even_filter(nums):
    for num in nums:
        if num % 2 == 0:
            yield num
def multiply_by_three(nums):
    for num in nums:
        yield num * 3
def convert_to_string(nums):
    for num in nums:
        yield 'The Number: %s' % num

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pipeline = convert_to_string(multiply_by_three(even_filter(nums)))
for num in pipeline:
    print num
# 输出:
# The Number: 6
# The Number: 12
# The Number: 18
# The Number: 24
# The Number: 30

我们动用了Python的关键字 yield,这个关键字主要是返回一个Generator,yield 是一个类似 return 的关键字,只是这个函数返回的是个Generator-生成器。所谓生成器的意思是,yield返回的是一个可迭代的对象,并没有真正的执行函数。也就是说,只有其返回的迭代对象被真正迭代时,yield函数才会正真的运行,运行到yield语句时就会停住,然后等下一次的迭代。(这个是个比较诡异的关键字)这就是lazy evluation。

好了,根据前面的原则——“使用Map & Reduce,不要使用循环”,那我们用比较纯朴的Map & Reduce吧。

def even_filter(nums):
    return filter(lambda x: x%2==0, nums)

def multiply_by_three(nums):
    return map(lambda x: x*3, nums)

def convert_to_string(nums):
    return map(lambda x: 'The Number: %s' % x,  nums)

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pipeline = convert_to_string(
               multiply_by_three(
                   even_filter(nums)
               )
            )
for num in pipeline:
    print num

但是他们的代码需要嵌套使用函数,这个有点不爽,如果我们能像下面这个样子就好了(第二种方式)。

pipeline_func(nums, [even_filter,
                     multiply_by_three,
                     convert_to_string])

那么,pipeline_func 实现如下:

def pipeline_func(data, fns):
    return reduce(lambda a, x: x(a),
                  fns,
                  data)

好了,在读过这么多的程序后,你可以回头看一下这篇文章的开头对函数式编程的描述,可能你就更有感觉了。

最后,我希望这篇浅显易懂的文章能让你感受到函数式编程的思想,就像OO编程,泛型编程,过程式编程一样,我们不用太纠结是不是我们的程序就是OO,就是functional的,我们重要的品味其中的味道

参考

补充:评论中redraiment这个评论大家也可以读一读。

感谢谢网友S142857 提供的shell风格的python pipeline:

class Pipe(object):
    def __init__(self, func):
        self.func = func

    def __ror__(self, other):
        def generator():
            for obj in other:
                if obj is not None:
                    yield self.func(obj)
        return generator()

@Pipe
def even_filter(num):
    return num if num % 2 == 0 else None

@Pipe
def multiply_by_three(num):
    return num*3

@Pipe
def convert_to_string(num):
    return 'The Number: %s' % num

@Pipe
def echo(item):
    print item
    return item

def force(sqs):
    for item in sqs: pass

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

force(nums | even_filter | multiply_by_three | convert_to_string | echo) 

(全文完)


关注CoolShell微信公众账号可以在手机端搜索文章

(转载本站文章请注明作者和出处 酷 壳 – CoolShell ,请勿用于任何商业用途)

——=== 访问 酷壳404页面 寻找遗失儿童。 ===——
好烂啊有点差凑合看看还不错很精彩 (58 人打了分,平均分: 4.83 )
Loading...

函数式编程》的相关评论

  1. 最后一个 reduce(lambda a, x: x(a), fns, data). 意思知道,但是实现原理我还得琢磨琢磨。

    1. 都有。程序中的状态不好维护,在并发的时候更不好维护。(你可以试想一下如果你的程序有个复杂的状态,当以后别人改你代码的时候,是很容易出bug的)

  2. 文章介绍得很全面!个人感觉只差临门一脚介绍函数作为第一类型的场景,即什么时候要自定义类似诸如find_if、copy_if这样的高阶函数。这就好比介绍面向对象编程时要指出什么时候需要自定义一个新的类。以下是我个人的理解:

    首先思考为什么引入“函数”,我认为最初的动机是为了避免重复的代码。例如,代码中反复地出现计算阶乘的代码时,就定义一个求阶乘的函数。但传统的函数只能接收诸如数值、字符串等“数据”作为参数。因此传统的函数能解决算法一致,仅数据可变的重复情况。

    但代码中还存在另一种重复,例如C语言里频繁地操作文件时,就会有一堆fopen、process、fclose;并行开发中也要反复出现lock、process、unlock……这一类代码,看起来有相同的模式,但又没办法把它独立成一个函数,因为中间的处理“代码”不同。如果能把“代码”作为参数传递给函数,那就好了!

    这正是把函数作为第一类型的作用:把代码作为数据。比如把 if (condition) {process} 看成一个函数的话,condition和process就是它的参数,其中process就是把代码作为参数。在支持函数式编程的语言里,我们能自定义类似if、while、for的控制语句(高阶函数)。

    以操作文件为例,可以定义一个with_open_file(filename, fn)函数:接收一个文件名和一个函数(代码),然后打开文件,让fn处理成功打开的文件,最后关闭文件。这样就无需重复得写fopen、fclose,再也不用担心忘记关闭文件。

    总结一下:函数作为第一类型的作用就是允许自定义控制语句、改造语言,让程序员能在更高的层次上做开发,而不是仅仅使用语言本身提供的for、if、while等低级的控制语句。比如Java语言通过不断地改进语法,引入了foreach(for (xx : xx))、with_open_file(try (resources))等语法,但如果Java最先引入Lambda,或许就不用添加这些语法糖了,因为程序员早就自己实现了!

    我之前写过一篇文章讨论这个问题,欢迎大家讨论和指正:http://zzp.me/2013-08-17/let-over-lambda/

  3. first class functions
    可以译成函数是一等对象。
    对于函数是一等“对象”的说法,本身就是源于程序本身的,也就是说当一个编程语言本身就是把函数当成一等公民的时候,那么我们就称呼这个语言拥有“first-class function”。
    在这种语言里面,函数的作用甚至超过基本数据类型本身,但是它又拥有最基本数据类型同样的待遇。

    对函数修饰当然还是用装饰器最帅!

    Declarative Programming vs Imperative Programming节的第三段代码第一行:
    “rom random import random”——开头缺个f

  4. 尾递归优化->尾调用优化:更好,scheme规范要求遇到尾调用都必须优化掉,而不限于尾递归的情况。

  5. 那个javascript版的reduce写错了,导致我无法理解最后一个reduce调用。 是不是应该写成下面这样:

    function reduce(actionFunction,list,initial){
    	var accumulate;
    	var temp;
    	if(initial){
    		accumulate = initial;
    	}
    	else{
    		accumulate = list.shfit();
    	}
    	temp = list.shift();
    	while(temp){
    		accumulate = actionFunction(accumulate,temp);
    		temp = list.shift();
    	}
    	return accumulate;
    }
    1. 谢谢更正,我本意是想实现个最简单的,不过,你这个实现更完整。我把文章中的做了一个更新,谢谢。

      1. 这个 reduce 的实现也有误导。
        传入的 list 在计算中被修改了,全部 shift 光了呀。
        另外,accumulate = list.shfit() 这里拼错了。

  6. 怎么这么神奇,刚才看评论里的代码还是纯文本,怎么刷一下变高亮了?
    var f = function(){};

  7. 简单易懂,却又体现了函数编程的魅力,好文!感谢分享。最近也在看clojure,感慨与functional programming简洁的魅力。

  8. Spring里面经常用到的template模式,比如jdbctempalte,基本能模拟用闭包保护资源的用法,但是匿名类写起来太累了,看着也不是很爽。
    @redraiment

  9. 或许皓哥可以适当地讲述一下FP中的模式识别。
    最近在学习Scala,这个特性犹如魔法一般,可以作出很多奇妙的玩意。

    比如,归并排序可以被这样写:

    def mergeSort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = {
    val n = xs.length / 2
    if (n == 0) xs
    else {

    //lt: Less Than Function
    def merge(xs: List[T], ys: List[T]): List[T] = (xs, ys) match {
    case (Nil, `ys`) => ys
    case (`xs`, Nil) => xs
    case (x :: xs1, y :: ys1) =>
    if (ord.lt(x, y)) x :: merge(xs1, ys)
    else y :: merge(xs, ys1)
    }

    val (fst, snd) = xs splitAt n
    merge(mergeSort(fst), mergeSort(snd))
    }
    }

    里面也是用到了递归,不过比一般的写法更加符合FP的思想。
    但是里面的模式识别更值得注意,因为它使得代码量更少也更易懂

  10. 赛车那个例子,函数式的写法是不是意味着我们需要在各个函数间不停复制传递整个数据段,而不是传递指针修改同一块内存?因为我经常写偏底层的代码,所以觉得相对于函数式实现来说,原来的实现应该更高效,至少对于机器来说,不知道是不是可以这样理解,或者编译器/runtime可以帮我们优化掉?看黑客与画家,里面作者反复提及他们用lisp实现的网站编辑程序比其它公司的更高效(机器性能方面),以我对函数式语言的理解没有办法理解这一点,不知道陈皓老师(这样称呼可以吧)能不能就这个试着讲解一下,非常感谢。
    不过,我也认为未来人的效率比机器的效率更重要,所以我所担心的机器效率问题,一方面随着硬件的提升或者编译器/runtime的进步可能渐渐就不是问题了,而且,在分布式系统之中,写出对人更高效,对并行更友好的程序可能的确比机器层面的效率更加有价值。
    非常感谢作者能够从实际代码层面讲解函数式语言的特性和优点,受益良多。

  11. fp其实就两点,支持嵌套函数定义,支持局部变量生命周期变长。至于尾递归优化,编译器支持就支持。惰性求值对编译器来说不容易优化,主要不容易分配寄存器。

  12. 我有个疑问,我觉得这里觉得例子很难说明问题但也过些过于简单。
    (1)这些例子说明的是可以比较简单地把数据处理划分成阶段的情况,即input->A processor ->B processor->…….->output
    但是如果有这种情况,即有些时候某些数据需要反馈,甚至对之前的stage的行为进行改变呢?比如B processor的输出会作为A的输入
    (2)用python的for i in xxxxx 实际上是很典型的map应用场景。但是有些时候(比如图像处理算法,当然这可能不算是典型应用)我不是对一个array或matrix进行规整访问的,而是每一次循环后才能确定下一次循环的index,这是我经常觉得反而python的语法很麻烦,因为无法像C一样自由地控制iterator的取值

  13. Deconstructing Functional Programming(http://www.infoq.com/presentations/functional-pros-cons) , 教你辩别FP炒作,分析FP的好坏,然后在非FP语言里应用FP核心思想。

  14. redraiment是字面语义角度来看,rasefon似乎是编译映射角度来看的,一步到位,佩服。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*