新普金娱乐网址


[转]WebGL All in One 全傻瓜简介

闲谈自个儿的学员们数学

开创适合学生的教学

  • 四月 08, 2019
  • 数学
  • 没有评论

成立符合学生的教学

当大家说到函数式编制程序来说,我们会合到如下函数式编制程序的长相:

读第七0条《要敢于鼓励学生“超大纲”》有感

  • 函数式编程的三大特征:
    • immutable data
      不可变数据
      :像Clojure一样,暗中认可上变量是不可变的,如若您要改成变量,你须求把变量copy出去修改。那样一来,能够让您的次第少很多Bug。因为,程序中的状态不好维护,在出现的时候更不好维护。(你可以试想一下只要你的先后有个复杂的状态,当以往人家改你代码的时候,是很不难出bug的,在彼在那之中那样的题材就越多了)
    • first class
      functions
      :那么些技能能够让您的函数就如变量一样来行使。也等于说,你的函数能够像变量壹样被创制,修改,并不失为变量一样传递,重回或是在函数中嵌套函数。这几个有点像Javascript的Prototype(参看Javascript的面向对象编制程序
    • 尾递归优化:我们知晓递归的害处,那正是只要递归很深的话,stack受不了,并会导致品质大幅下跌。所以,大家采纳尾递归优化技术——每一遍递归时都会引用stack,那样一来能够晋级质量,当然,那亟需语言或编写翻译器的援救。Python就不协助。

即墨区文峰中学  程挺模

“每二个小家伙的思辨发展都有其卓绝的征程,每多个小孩子的聪明和才智都各有各的特色。未有其余几个好端端的女孩儿是不要能力、毫无天赋的。……不要让别的3个幼儿在低于他的才能的品位上学习”。阅读苏霍在第100条提出的开篇语,小编首先想到她以前边向全体学生建议的教学情势:

  • 函数式编程的多少个技巧
    • map &
      reduce
       :那些技能毫无多说了,函数式编程最普遍的技巧正是对2个集结做Map和Reduce操作。那比起进度式的语言来说,在代码上要更便于阅读。(守旧进程式的言语供给利用for/while循环,然后在各个变量中把数据倒过来倒过去的)这些很像C++中的STL中的foreach,find_if,count_if之流的函数的玩法。
    • pipeline:这几个技能的情致是,把函数实例成1个1个的action,然后,把1组action放到2个数组或是列表中,然后把数据传给这些action
      list,数据就像1个pipeline1样顺序地被各种函数所操作,最后收获大家想要的结果。
    • recursing
      递归
       :递归最大的功利就简化代码,他能够把一个复杂的难题用异常粗略的代码描述出来。注意:递归的精华是讲述难点,而这多亏函数式编制程序的精髓。
    • currying:把一个函数的几个参数分解成三个函数,
      然后把函数多层封装起来,每层函数都回到2个函数去接受下贰个参数这样,可以简化函数的七个参数。在C++中,那么些很像STL中的bind_1st或是bind2nd。
    • higher order function
      高阶函数
      :所谓高阶函数正是函数当参数,把传播的函数做一个装进,然后回到这些封装函数。现象上就是函数字传送进传出,就如面向对象对象满天飞一样。

针对一般学生,他在第37条建议《让每叁个学生都有爱好做的事》中,提到了培育学生读书和喜爱一门课程的做法;在第4⑧条提出《“思维课-到宇宙去旅行”》中,提到了让学员观看自然、分析因果关系、升高思维认识的做法;在第伍0条建议《必须教会学生阅读》中,提到了翻阅、思量、表明自动化的根本意义。

 

针对学困生,他在第3九条《阅读是对上学困难的学习者展开智育的第3手段》中,提到了学困生要依赖阅读发展智慧,学困生读书越来越多,他的牵记越清楚,他的智力商数力量越活跃;在第5三条建议《学习愿望是学生读书活动的根本动机原因》中,提到了要让学困生对课堂引起优异的心气感觉,在制伏困难进度中,得到道义上的满意感。在不计其数稿子中,苏霍还对尤其的学困生建议了专用的读书书籍、习题集、特殊作业,扶助他们绵绵赢得发展,进而获取学习的自信心,那样的异样照顾甚至是直接继续好几年。

  • 再有函数式的有的便宜
    • parallelization
      并行:
      所谓并行的趣味正是在互相环境下,各类线程之间不要求联合或互斥。
    • lazy evaluation
      惰性求值
      :那么些要求编写翻译器的支撑。表明式不在它被绑定到变量之后就及时求值,而是在该值被取用的时候求值,也正是说,语句如x:=expression; (把一个表明式的结果赋值给3个变量)显然的调用这一个表明式被总括并把结果放置到 x 中,然而先不管实际在 x 中的是怎么样,直到通过前面包车型大巴表明式中到 x 的引用而有了对它的值的须要的时候,而前面表明式本身的求值也可以被延迟,最后为了扭转让外界看到的有个别符号而计量这么些急忙增进的信赖树。
    • determinism 确定性:所谓分明的情致就是像数学那样 f(x) = y
      ,这么些函数无论在如何情形下,都会拿走平等的结果,那几个我们称为函数的强烈。而不是像程序中的很多函数那样,同三个参数,却会在区别的气象下总括出不相同的结果。所谓不相同的意况的情致正是大家的函数会依照局地运营中的状态信息的比不上而发生变化。

梳理苏霍前边提议的那几个建议,表明她对教学面向全部学生的认识,不相同的上学的儿童总有两样教学方法,目标就是“不让二个上学的小孩子掉队”。

地点的那个东西太肤浅了,依旧让大家来循序渐近地看有的例证吗。

除了这几个之外关切全部学生的“大头”和学困生的“难题”,在第玖0条建议中,苏霍首次提议了有先性子、有才干的“尖子生”的教学策略。他说,“大家履行的尺度是:每贰个学员在念书中都应该达到她能够的姣好”
,对于学有余力的学员,能够“在他们有能力的这几个学科上和创制性活动的小圈子里当先教学大纲的限度”。从高端发展来讲,正是鼓励学员发展“冒尖”。看到“力所能及”,我又想开“各尽所能”那么些词。小编的知道是“力所能及”是指向全体学生而言的,“各尽所能”是针对不一致层次学生的须求的,前者的角度是“全体”,后者的角度是“周到”。尖子生的“各尽所能”因为要“超大纲”,所以一定于是“周密进步”的限制变大了。

咱俩先用二个最简易的例子来证美素佳儿下怎么是函数式编制程序。

世家掌握,香港(Hong Kong)的冯恩洪提议了“创建适合学生的教导”的见识,嘉兴的赵桂霞校长建议了“适才教育”理念,都以面向全部学生和关切学生到家上扬的。可是,由于进行素质教育和九年义教的原由,中型小型高校长和教师职员和工人对什么样培育尖子学生座谈的并不多,应该说特长类学生的扶植工作做了过多,但学科知识深化和展开的斟酌却涉猎不多,更不用说学科方面培育“精英”学生了。甚至是一谈学科“精英”学生,就象是违背了素质教育似的。

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

苏霍举了数学和情医学习的例子。数学教授在给学生布置作业时,总是出二种难度不等的方案,让学生去挑选他可以的标题去做,让每2个学员在高层次的难点上考验一下自个儿的能力,在终端生“惺惺相惜”的较量中公布天才才能。物理老师在教学课节时,找出一些超纲难题让最有才干的学习者去课外钻探,拓展文化层面。苏霍希望见到那几个学员在图书室、观望室查资料,在该校的各种职能工作室和“难事之角”进行同步切磋。当教授觉得条件成熟的时候,就集体学术报告会、科技(science and technology)晚会,让学员发言,作报告,同时吸引有喜欢的上学的小孩子同步参预那样的展开研讨。应该说,那像是我们羡慕的才女学生协会。非但不是应试,而是反映了学习样式拓展化和两种化。

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

阅读此文建议,对终端生的构建,作者想有两点启示:

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

一是赤手空拳培养和练习组织关系。

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

率先建立学科进行精英小组。首要指标是担任学科首席学生,引导班级学生。每一种学科从课代表中选拔优良学生担任学科首席,学科首席学生壹边要从课程老师那里适合深化和实行学科知识,另一方面还要负担各小组的疑难解答难点,同时学科首席为级部精英协会成员,参加级部组织引导活动。

你或许会以为这一个例子太普通了。是的,那几个事例就是函数式编制程序的守则:不借助于于外部的数据,而且也不改动外部数据的值,而是再次来到多个新的值给您

再是建立校级学科精英组织。重要目标是展开学科学习内容,加深知识通晓。例如,语文科目以单元大旨活动为载体,以开始展览阅读为重点情势,形成“文峰讲坛”类别核心,提高学生独立阅读掌握能力;爱沙尼亚语学科形成“歌舞青春”和“阅读配音”协会,作育学生语言表明能力;数学课程创制“智慧数学”团队,联系生活、生产事例,抽取数学模型,解答应用难题,提高数学化解实际难点能力。等等。今后,作者校已经协会了相关学科团队,是面向全体的照料差距的混合型团队,要在此基础上,以级部为单位分别设计“拓展组织”,定期协会专题钻探报告会,效果会更加好。

咱俩再来看三个简易例子:

2是筛选培养和演习学习内容。

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

协会关系是培育的样式,选取培训内容是读书的机要。内容的选择能够包罗七个方面,一个是升级拔高的延伸文化,三个是拓展认识的履行知识。以物教育学科为例:伏安法测电阻是早晚调查的学员实验,唯有贰只电衡量指示仪表和开关、变阻器组合也能测出电阻,是属于侦察学生的创建性实验和应变能力。若是联系高粤语化,可以介绍三种控制电路,利用滑动变阻器表达限流电路和分压电路的得失,那是文化的加重精通。另三个方面是知识的展开认识,要挂钩生活和生产实际的例证,如让学生收集以后推广的太阳能(风能)发电的图景,从发电原理、电路结构,优点前景以及哪些升级发电量,做出专题报告,有利于培养学生关于STS(社会、科学、技术)的体会范围。

咱俩得以看来地点13分例子inc()函数再次回到了另三个函数incx(),于是大家得以用inc()函数来协会种种版本的inc函数,比如:inc二()和inc伍()。这么些技术其实正是地方所说的Currying技术。从那个技术上,你或然体会到函数式编制程序的见解:把函数当成变量来用,关切于描述难题而不是怎么落到实处,那样能够让代码更易读。

在苏霍看来,能力较强、发展水平较高、天赋较好的学员“超大纲”学习对上学较差的、相比较平庸的学童也是有影响的,因为种种课程小组、技术小组、以及种种课外活动、报告会、解说会都会对全体学员都起着非常的大的意义。那虽是理想的动静,但那种情形是令人向往的。

Map & Reduce

在函数式编制程序中,大家不该用循环迭代的艺术,大家应当用更为高级的不2诀窍,如下所示的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的11分例子中大家能够观察,大家写义了一个函数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表明式中有多个参数,也正是说每趟从列表中取两个值,总结结果后把那些值再放回去,上边包车型大巴表明式也便是:((((一+二)+三)+肆)+伍)

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
 –
表明式编制程序。

下边我们看一下有关的以身作则(本示例来自那篇小说 )。

例如,我们有3辆车竞技,简单起见,大家独家给那3辆车有7/拾的票房价值可现在前走一步,1共有6遍机遇,大家打出每3遍那3辆车的上扬状态。

对此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块其意况。于是,大家在读代码的进程时,每当大家进来到函数里,1量读到访问了三个外部的变量,我们立刻要去查看这一个变量的上下文,然后还要在大脑里推演这些变量的情况,
大家才晓得程序的真的逻辑。也便是说,这几个函数间必需知道其余函数是怎么修改它们之间的共享变量的,所以,这个函数是有意况的

大家精晓,有气象并不是1件很好的作业,无论是对代码重用,依旧对代码的交互来说,都以有副成效的。因而,大家要想个方法把那几个情状搞掉,于是出现了我们的
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的管道操作——把多少个指令串起来,后面命令的输出成为后边命令的输入,如此成就3个流式总括。(注:管道相对是二个宏大的发明,他的设工学正是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怎么玩?

大家先来看3个之类的次第,那一个程序的process()有两个步骤:

一)找出偶数。
2)乘以3
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(第3种方法)应该怎么写?

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,那个第2字首假诺回去三个Generator,yield
是一个近乎 return
的要紧字,只是那个函数重返的是个Generator-生成器。所谓生成器的情趣是,yield再次回到的是3个可迭代的靶子,并未有当真的实践函数。也便是说,唯有其归来的迭代对象被真正迭代时,yield函数才会正真的周转,运维到yield语句时就会停住,然后等下3遍的迭代。(这一个是个相比奇特的最主要字)那正是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八57 提供的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

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图