函数编程, 任何人可以以任何方式随意转载.

清剿太监贴~~ , 把没完成的东西完成之

-- hoxide [2004-09-08 23:06:48]

前言

函数式编程的概念

python中的函数编程

lambda

   1 lambda x: x+1

   1 >>> lambda x: x+1 # 生成一个匿名函数 λ(x) = x+1
   2 <function <lambda> at 0x00C99770>
   3 >>> f = lambda x: x+1 # 将这个函数绑定名字 'f'
   4 >>> f(1) # 调用 'f'
   5 2

   1 def name(parameter_list):
   2     return expression

高阶函数

map

   1 >>> a = range(5);
   2 >>> b = range(4);
   3 >>> map(lambda x, y: (x, y) , a, b) # lambda x,y 接受两个参数, 生成个包含这两个参数的tuple.
   4 [(0, 0), (1, 1), (2, 2), (3, 3), (4, None)]

   1 >>> ml = [[0, 1], [2, 3], [3, 4]]
   2 >>> map(lambda (x,y): x+y , ml) # lambda (x,y): x+y 接受一个有两元元组(tuple), 计算他们的和.
   3 [1, 5, 7]

   1 >>> a = range(3)
   2 >>> map(None , a)
   3 [0, 1, 2]

reduce

reduce( function, sequence[, initializer])

将函数function从左到右作用在序列的每个元素上, 函数function为二元函数, 第一个变量为上次计算所得结果,第二个变量为列表元素. 具体得:

   1 >>> reduce(lambda x,y: x+y , [1,2,3,4,5]) # 相当于 ((((1+2)+3)+4)+5)
   2 15

整个计算过程就像列表在不断缩减一样.

initializer为初值. 例如:

>>> reduce(lambda x,y: x+y , [1,2,3,4,5], 10) # 相当于(((((10+1)+2)+3)+4)+5)
25

filter

filter( function, list)

filter 过滤器.

从list的元素中构造一个列表, 这个列表的元素依次是list中使function为真的元素. list可以是任意序列, 如列表(List)和元组(Tuple)等, 或支出迭代子的容器, 或者迭代子(有关容器,迭代子等概念将在下面介绍,)

例子:

   1 >>> filter(lambda x: x>5 , [10,1,5,6,7]) # 将列表中小于5的元素滤去.
   2 [10, 6, 7]

和map一样, 若function是None , 则代为恒等函数, 这样将滤去所有取值为false的元素(包括0和None).

列表运算

基本形式是 [expression for expression_list in testlist ]

和前面一样 testlist 是一个序列或者迭代子 expression是一个表达式 expression_list 是这个表达式中的参量列表(实质上是解开一个元组). 例如:

   1 >>> [ x+y for x,y in [(1,2), (2,3), (4,5)]]
   2 [3, 5, 9]
   3 >>> [ item[0]+item[1] for item in [(1,2), (2,3), (4,5)]] # 和前面的等价
   4 [3, 5, 9]

for 语句可以套用:

   1 >>> [ (i,j) for i in range(5) for j in range(3)] # 这个例子可以看出靠近expression的循环是内层循环
   2 [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2)]

for后面还可以跟if语句, 这样相当于一个增强的 filter

例如:

   1 >>> [ i for i in range(10) if i%2==0] # 选出所有偶数
   2 [0, 2, 4, 6, 8]

同样 if 也可以嵌套, 并可以与for混合嵌套 (但是, 显然过多的嵌套容易使语句变得晦涩难懂) :

   1 >>> [ (i,j) for i in range(10) if i%2==0 for j in range(10) if j%3 == 0] 
   2 [(0, 0), (0, 3), (0, 6), (0, 9), (2, 0), (2, 3), (2, 6), (2, 9), (4, 0), (4, 3), (4, 6), (4, 9), (6, 0), (6, 3), (6, 6), (6, 9), (8, 0), (8, 3), (8, 6), (8, 9)]

基本方法综述

前面很粗浅得讲了一下Python中函数编程的最基本内容, 下面将列出一些常用的函数编程方法, 这些方法可以大大简化你的代码.

应用实例

编程的东西如果理解原来, 不管用那种方法写程序其实都是一样的, 函数编程只是一种方法, 用好了可以简化程序.

算24点的程序

这只是一个用了点函数编程方法随手写的程序, 1年前的东西, 不是算24点的最好方法, 拿到这里, 只是展示一下函数编程的用法.

   1 funs = [ lambda x, item: (x+item[0],
   2                                str(x)+'+('+item[1]+')'
   3                               ),
   4       lambda x, item: (x-item[0],
   5                                str(x)+'-('+item[1]+')'
   6                               ),
   7       lambda x, item: (item[0]-x,
   8                                '('+item[1]+')-'+str(x)
   9                               ),
  10       lambda x, item: (x*item[0],
  11                                str(x)+'*('+item[1]+')'
  12                               ),
  13       lambda x, item:   (item[0]==0 and (0,'ZZZ')) or \
  14                         (x/item[0],
  15                                str(x)+'/('+item[1]+')'
  16                               ),
  17       lambda x, item:   (x==0 and (0,'ZZZ')) or \
  18                         (item[0]/x,
  19                                '('+item[1]+')/'+str(x)
  20                               )
  21 ]
  22 
  23 def con(num):
  24     l = len(num)
  25     p = list()
  26     if l==1: return {num[0]:str(num[0])}
  27     for i in range(l):
  28         for f in funs:
  29             p += map(lambda item: f(num[i],item),
  30                        con(num[:i]+num[i+1:]).items()
  31                     )
  32     return dict(p)
  33 
  34 print con(map(float,[1,5,6,7])).get(21.0,0)

函数编程的缺陷

例子

交流

fp4python (last edited 2009-12-25 07:15:25 by localhost)