函数式编制程序哲学

0.

您深夜起来去五星级餐厅吃早餐。
借使您有充分的时日,你能够细嚼慢吞,先水果,在主食,再点心,最后来杯咖啡。

但你去的时候,发现还有5分钟就要收摊了。
您该如何做?

当大家提起函数式编制程序来说,咱们会看出如下函数式编制程序的长相:

1.

二年前,小编的读书能力处于第一阶段。
自家的阅读状态是每周读一本书,写一篇书评。
周周读1本书,我是从第二页要看看最终一页的。
写壹篇书评,也是勉强从书中摘要一些段子,加上自个儿的感受,凑个800字。

这种阅读方式的功利是,让祥和对读书未有压力。
反正每一天只要花个贰拾陆秒钟,壹本200多页的书,肯定七天能看完。

  • 函数式编制程序的3大特征:
    • immutable data
      不可变数据
      :像Clojure一样,暗许上变量是不可变的,若是您要改变变量,你必要把变量copy出去修改。这样1来,能够让你的主次少很多Bug。因为,程序中的状态倒霉维护,在出现的时候更倒霉维护。(你能够试想一下万一您的次第有个复杂的情况,当现在人家改你代码的时候,是很简单出bug的,在互动中那样的标题就越来越多了)
    • first class
      functions
      :那么些技术能够让你的函数就如变量一样来选取。也正是说,你的函数可以像变量壹样被成立,修改,并当成变量1样传递,再次来到或是在函数中嵌套函数。那一个有点像Javascript的Prototype(参看Javascript的面向对象编制程序
    • 尾递归优化:咱们领略递归的害处,那就是只要递归很深的话,stack受不了,并会导致质量大幅度回落。所以,大家应用尾递归优化技术——每一遍递归时都会引用stack,那样一来能够晋级质量,当然,那亟需语言或编写翻译器的支持。Python就不协助。

2.

但后来怎么会去学学速读吧?
是因为本人碰着阻力了。

笔者的地点产生了变化,作者从二个程序员提高到了管制职位,而且本身还伊始做产品。
原本程序员的时候,小编只必要把编制程序的书看好,然后接触部分新领域的技艺就可以了。
本身的开卷都以文化艺术,历史,管法学通识,管理学入门之类的。

到了管制职位今后作者意识,作者发觉要学习很多新的东西:

发展汇报,向下管理,同级沟通,项目管理,业余谈判··· ···

每1样都是内需特地球科学习的。
可是很遗憾,小编在的半导体收音机公司纵然年产值也有三个亿,然则却从未为自作者的职责设置培养和磨炼铺排。

3.

自家未来常常讲3个概念叫“无证上岗”,说的正是自身立时的动静。
硕士未有通过职业技术培养和磨练就一向上岗工作了;
广大人从未读书相处相爱就上岗去谈恋爱了;
洋洋伉俪没有上学育儿就一直上岗做家长了;

世家都以“经验主义”,边学边干。
但是事实上大家忽略了,大家实际上有很棒的园丁的:那些老师正是书籍。
书籍最实质的效应正是传播知识,讲人类文明的成果延续下去。

小编们为啥不让选取书籍当我们的教育工小编呢?
我们为啥不选择自身培训呢?

  • 函数式编制程序的几个技术
    • map &
      reduce
       :这些技能毫无多说了,函数式编程最普遍的技巧就是对二个汇集做Map和Reduce操作。那比起进程式的言语来说,在代码上要更易于阅读。(古板进程式的言语需求运用for/while循环,然后在各类变量中把多少倒过来倒过去的)这一个很像C++中的STL中的foreach,find_if,count_if之流的函数的玩法。
    • pipeline:这么些技术的情致是,把函数实例成一个1个的action,然后,把1组action放到贰个数组或是列表中,然后把数据传给那么些action
      list,数据就像2个pipeline一样顺序地被各类函数所操作,最终取得大家想要的结果。
    • recursing
      递归
       :递归最大的利益就简化代码,他能够把二个繁杂的题目用很简短的代码描述出来。注意:递归的美丽是讲述难题,而那多亏函数式编制程序的精华。
    • currying:把1个函数的八个参数分解成多个函数,
      然后把函数多层封装起来,每层函数都回去叁个函数去接受下3个参数那样,能够简化函数的多少个参数。在C++中,这么些很像STL中的bind_1st或是bind2nd。
    • higher order function
      高阶函数
      :所谓高阶函数正是函数当参数,把传播的函数做三个打包,然后回来这几个封装函数。现象上就是函数传进传出,就像是面向对象对象满天飞1样。

4.

于是本人起来去读书《高功效人员的四个习惯》《有效联系》《领导梯队》《全新思维》之类的实用类书籍。

不过,大家都晓得,那类书籍太多了。
要学的小圈子如此多,要看的图书这么多,但能够使用的年月每一天唯有二十九分钟。

怎么办?
归来大家小说初叶的早饭难点:
但你去早餐厅的时候,发现还有伍分钟就要收摊了。
您改怎么办?
——当然是吃你最必要吃的,简单下口的主食。

开卷的本质:就算在可以使用的日子,以友好力所能及领略的水平去上学
日子有限,是当下我们每1位都要直面包车型客车题材,它大约不可以改变;
就此,能更改的,就唯有我们对此阅读的法子了。
大家要从试图理解一本书,变成明亮书中的1段话,3个概念。

 

5.

第二个阶段,小编遇到了高速阅读。
神速阅读的80\20法则让自家发现,作者原来5日读一本干货书其实有点浪费时间。
因为书中有诸多小编以往不要求,不过自身觉得以后或者有效的文化。

拆书帮帮主赵周先生的《这样读书就够了》,正是一本有关怎么着阅读实用类书籍的指南。

一本书假诺有二个片段,你能够学以致用,那整本书的价值你就赚回来了。

A:把一本书从头翻到尾,最后只是记住了中间的1八个点;
B:带着题材,火速从目录寻找到温馨想要理解的章节,然后找到答案,然后获得工作和生活中动用。

你挑选哪位?

  • 还有函数式的有的益处
    • parallelization
      并行:
      所谓并行的意趣正是在互相环境下,各样线程之间不必要联合或互斥。
    • lazy evaluation
      惰性求值
      :这些要求编写翻译器的支撑。表明式不在它被绑定到变量之后就随即求值,而是在该值被取用的时候求值,也便是说,语句如x:=expression; (把3个表达式的结果赋值给二个变量)鲜明的调用这几个表明式被总括并把结果放置到 x 中,可是先不管实际在 x 中的是如何,直到通过前面包车型大巴表明式中到 x 的引用而有了对它的值的须要的时候,而前面表达式本人的求值也可以被延迟,最终为了转变让外界看到的有个别符号而计量这么些急忙拉长的借助树。
    • determinism 确定性:所谓分明的意思就是像数学那样 f(x) = y
      ,那么些函数无论在怎么样情状下,都会拿走壹致的结果,这几个我们称为函数的显明。而不是像程序中的很多函数那样,同1个参数,却会在不一样的现象下计算出分化的结果。所谓分化的气象的情致就是我们的函数会依据部分运维中的状态音信的不如而产生变化。

6.

自家得以完结1天壹本书,写①篇书评的速度。
相当慢阅读满足了本身的虚荣心,也让自个儿开首能够带着干活中的质疑去火速找到答案。

它实际也远非让作者难以忘怀多少东西(作者用到自个儿的劳作和生活中的,作者都挥之不去了)。
但以此历程却让本人开首发现本人的原状和好客。

管理学,历史,经济学,量子物管理学,产品,经济,创业,情绪学,手绘,时间管理,项目管理,职业规划,知识管理,阐述,调换,阅读,写作,编剧,典故,个人品牌,手账,整理术,认知···
···

学学那几个世界的时候,笔者还用到了四个主意叫宗旨阅读。
相当于同时对三个话题的几本甚至十几本书举办火速阅读。
它越发契合您快速商讨3个领域,整合大家的理念。

本人的社会风气从原本的程序员世界,一下子囫囵吞枣的经验了广大学本科人想都不敢想的园地。
自家都尚未看过世界,笔者哪来的人生观?

上边包车型地铁那个东西太肤浅了,还是让我们来循序渐近地看有的例子吗。

7.

其四个等级: 精读。
过于追求数量之后,作者发觉实际和一本书从头读到位一样,是另二个极致。

有人平常问笔者,李笑来老师让我们精读不要速读,小6您怎么看?

一年前,小编憋着气说:

哼!那不就是事业有成功成名就的人让我们学金刚经修身养性壹样呢?

至今笔者会说,哎哎,李笑来老师说的对!
您一年读了200本书,你最后会发现,值得您往往去读的,也许就三-5本。
那三-5本,你最后家里放壹本,集团放一本,包里也放一本,时不时拿出去读读呀。

我们先用二个最简便易行的例证来验证一下哪些是函数式编程。

8.

第七个阶段,我在翻阅的时候,小编会忘记本身用哪些阅读情势。

本身前天每一日午夜坐早读节目,那个栏目会七日拆解一本书。
偶尔1个上午回拆解3个章节,有时候会拆开1个定义。
譬如说昨日深夜,大家在拆除与搬迁孙圈圈的《请结束无效努力》(书名很鸡汤,可是内容真的很棒)。
本人大概先快捷阅读,找到她整本书的主导概念。
接下来作者看看这个概念是否本人都很熟识,假使不是,笔者会去探视他是如何讲解的。

例如自身看齐他涉嫌八个概念叫溢价,那几个自家不是很纯熟。
于是乎小编就以此概念,去今日头条,找价格一定的书,然后设计了一遍贰十5分钟直播内容微课。

先看三个非函数式的事例:

9.

两年前,作者刚接触快捷阅读的时候,作者像发现新陆地的布里斯托,随处去传播和宣传飞快阅读是怎样怎样的高速;
相遇思疑,作者会以理据争,依据本身的逻辑总结说服反对者。

于今,作者知道了,其实哪有何阅读方式呢?
写书的人,在写那本书的时候,未有想过读者会怎么读呀;
做菜的名厨,在做那道菜的时候,也常有不曾想过食客会以怎么样方法去吃啊;

书是“空性”的,首要的是您如何对待它,利用它。
故此笔者在自家的球葱阅读课中,除了让大家通晓阅读的工具方法,更器重的是让我们喜欢阅读,喜欢本身阅读的气象。

球葱阅读课-第1季

1
2
3
4
int cnt;
void increment(){
    cnt++;
}

10.

小结一下自家是怎么进步自个儿的阅读能力的呢。
先是个级次:随心所欲,二十四日一本书;
第叁个级次:飞快阅读+大旨阅读,打开眼界,接触愈来愈多恐怕;
其三个阶段:精读,从速读的书中,发现实价值得反复读的书籍;
第多少个等级:随心所欲,不再执着工具和方法。

书,怎么读都能够。
只要你永不忘记阅读的原形:
在能够应用的时刻,以投机能够领略的法子去学学。
本身认为就就足足了。


自家是小陆,18年笔者会帮忙更加多的人喜好上阅读。

那么,函数式的应有怎么写啊?

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

您也许会以为那几个事例太普通了。是的,那么些事例正是函数式编制程序的守则:不借助于表面包车型客车多寡,而且也不转移外部数据的值,而是回到八个新的值给你

大家再来看三个简练例子:

1
2
3
4
5
6
7
8
9
10
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函数,比如:inc贰()和inc5()。那个技术其实就是地点所说的库里ing技术。从那个技能上,你也许体会到函数式编制程序的视角:把函数当成变量来用,关切于描述难题而不是怎么落实,那样能够让代码更易读。

Map & Reduce

在函数式编程中,大家不该用循环迭代的艺术,大家相应用更为高级的不二秘籍,如下所示的Python代码

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

你能够看看如此的代码很易读,因为,这么的代码是在讲述要干什么,而不是怎么干

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

1
2
3
4
5
6
def toUpper(item):
      return item.upper()
 
upper_name = map(toUpper, ["hao", "chen", "coolshell"])
print upper_name
# 输出 ['HAO', 'CHEN', 'COOLSHELL']

顺手说一下,上边的例子个是或不是和大家的STL的transform有个别像?

1
2
3
4
5
6
7
8
9
10
11
12
#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的卓殊例子中我们能够看出,大家写义了3个函数toUpper,这一个函数未有变动传进来的值,只是把传进来的值做个不难的操作,然后回来。然后,大家把其用在map函数中,就能够很领悟地叙述出大家想要干什么。而不会去领悟三个在循环中的怎么落到实处的代码,最后在读了好多巡回的逻辑后才意识原先是那么些或尤其意思。
上面,大家看看描述实现格局的进度式编程是怎么玩的(看上去是或不是不比函数式的清晰?):

1
2
3
4
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

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

我们再来看看reduce怎么玩?(下边的lambda表明式中有多个参数,约等于说每一次从列表中取七个值,总结结果后把这一个值再放回去,上面的表明式约等于:((((壹+2)+三)+4)+伍)

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

Python中的除了map和reduce外,还有局地其余如filter, find, all,
any的函数做扶助(其余函数式的言语也有),能够让您的代码更加精简,更易读。
大家再来看多个相比复杂的例证:

计算数组中正数的平均值
1
2
3
4
5
6
7
8
9
10
11
12
13
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

借使用函数式编制程序,那么些例子能够写成那样:

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

C++11玩的法:

1
2
3
4
5
6
7
8
9
10
11
12
#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;

大家能够观望,函数式编程有如下好处:

一)代码更简便易行了。
贰)数据集,操作,再次回到值都放到了协同。
叁)你在读代码的时候,未有了循环体,于是就足以少了些一时半刻变量,以及变量倒来倒去逻辑。
四)你的代码变成了在叙述您要怎么,而不是怎么去干。

最终,大家来看一下Map/Reduce那样的函数是怎么来落实的(上面是Javascript代码)

map函数
1
2
3
4
5
6
7
var map = function (mappingFunction, list) {
  var result = [];
  forEach(list, function (item) {
    result.push(mappingFunction(item));
  });
  return result;
};

下面是reduce函数的javascript实现(谢谢 @降雨在家 核对的自家原本的简短版本)

reduce函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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
 –
注解式编制程序。

上面我们看一下连锁的言传身教(本示例来自那篇小说 )。

譬如说,我们有三辆车比赛,不难起见,大家分别给这叁辆车有十一分之7的可能率可未来前走一步,1共有八回机遇,大家打出每贰遍那三辆车的开拓进取状态。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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]

我们得以把这一个两重循环变成壹些函数模块,那样便于大家更易于地读书代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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()

上面包车型客车代码,大家能够从主循环开头,大家得以很明亮地看到程序的主题,因为我们把程序的逻辑分成了多少个函数,那样1来,大家的代码逻辑也会变得多少个小碎片,于是大家读代码时要思量的上下文就少了累累,阅读代码也会更易于。不像第3个示范,如果未有注释和认证,你照旧要求花些时间精晓一下。而把代码逻辑封装成了函数后,我们就一定于给种种相对独立的次序逻辑取了个名字,于是代码成了自解释的

而是,你会发现,封装成函数后,那么些函数都会凭借于共享的变量来三头其情景。于是,我们在读代码的长河时,每当咱们进入到函数里,壹量读到访问了三个外表的变量,大家立时要去查看这些变量的上下文,然后还要在大脑里推演那么些变量的景观,
大家才知道程序的着实逻辑。约等于说,那几个函数间必需知道其余函数是怎么修改它们中间的共享变量的,所以,这个函数是有事态的

作者们知道,有情况并不是一件很好的事情,无论是对代码重用,照旧对代码的竞相来说,都以有副作用的。由此,大家要想个方法把这几个景况搞掉,于是应运而生了大家的
Functional Programming
的编程范式。上面,我们来看看函数式的主意应该怎么写?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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的。因为它们有八个症状:

壹)它们之间从未共享的变量。
二)函数间通过参数和重临值来传递数据。
三)在函数里未有方今变量。

大家还是可以够看来,for循环被递归取代了(见race函数)——
递归是函数式编程中带用到的技巧,正如前方所说的,递归的本来面目正是描述难题是怎么。

哲学 1

Pipeline

pipeline 管道借鉴于Unix
Shell的管道操作——把多少个指令串起来,后边命令的出口成为后面命令的输入,如此成就1个流式总括。(注:管道相对是五个壮烈的表明,他的设军事学正是KISS

让种种效率就做一件事,并把那件事做到极致,软件或程序的拼装会变得愈加简单和直观。那几个布署意见影响特别有意思,包蕴前些天的Web
Service,云计算,以及大数据的流式计算等等)

比如,大家如下的shell命令:

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

假定大家抽象成函数式的语言,就如下边那样:

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

也得以接近下边那一个样子:

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

好了,让我们来探视函数式编制程序的Pipeline怎么玩?

大家先来看贰个之类的次第,那么些顺序的process()有八个步骤:

一)找出偶数。
2)乘以3
三)转成字符串重回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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(第二种方法)应该怎么写?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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
是2个近乎 return
的显要字,只是这些函数再次来到的是个Generator-生成器。所谓生成器的意思是,yield重返的是三个可迭代的对象,并未当真的施行函数。也正是说,只有其归来的迭代对象被真正迭代时,yield函数才会正真的运作,运营到yield语句时就会停住,然后等下叁次的迭代。(这么些是个比较奇特的重点字)那正是lazy
evluation。

好了,依照前边的尺度——“动用Map &
Reduce,不要选拔循环
”,那我们用相比较朴实的Map & Reduce吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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

而是她们的代码须要嵌套使用函数,那些有点难受,如若我们能像上边这么些样子就好了(第两种方式)。

1
2
3
pipeline_func(nums, [even_filter,
                     multiply_by_three,
                     convert_to_string])

那么,pipeline_func 实现如下:

1
2
3
4
def pipeline_func(data, fns):
    return reduce(lambda a, x: x(a),
                  fns,
                  data)

好了,在读过这么多的次第后,你能够回头看一下这篇小说的初叶对函数式编制程序的讲述,大概您就更有感觉了。

最后,本人盼望那篇浅显易懂的稿子能让你感触到函数式编制程序的思量,就像OO编制程序,泛型编程,进度式编制程序一样,大家毫不太纠结是还是不是大家的主次就是OO,就是functional的,大家重视的品尝个中的意味

参考

补充:评论中redraiment以此评价世家也得以读一读。

感多谢网上好友S142捌伍七 提供的shell风格的python pipeline:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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)

转发自酷壳,本身留作笔记,感觉不错,原来的书文地址:http://coolshell.cn/articles/10822.html

相关文章

Comment ()
评论是一种美德,说点什么吧,否则我会恨你的。。。