python函数式编程

1, lambda

lambda可以创建匿名函数，一个完整的lambda表达式格式如下:

lambda [arg1[, arg2, ... argN]]: 返回值

lambda表达式返回一个可调用的函数对象。

>>> func = lambda x:x*2
>>> func
<function <lambda> at 0x01E2E130>
>>> func(3)
6

有默认参数的lambda表达式：

>>> func = lambda a,b = 2: a + b
>>> func(1)
3
>>> func(1,3)
4

变长参数的lambda表达式：

>>> func = lambda *a: [it * 2 for it in a]
>>> func(1,3)
[2, 6]

2.filter

filter用法如下：

filter(func, seq)

bool 函数func作用于seq序列中的每一个元素，返回一个使func为True的的序列

>>> func = lambda a: a%2
>>> filter(None,(1,2,3,4))
(1, 2, 3, 4)
>>> filter(func,(1,2,3,4))
(1, 3)

3.map

map的用法如下：

map(func, seq1[,seq2...])

map将函数func作用于seq序列的每个元素上，返回一个func函数返回值的列表。

>>> func = lambda a: a*2
>>> map(func, (1,2, 3))
[2, 4, 6]
>>> map(None, (1,2, 3))
[1, 2, 3]

map参数有多个序列时，依次取出各个序列的第i个元素，组成元组，func作用于该元组，返回func返回值的列表。

>>> map(lambda a, b: a+b, (1,2,3), (1,1,1))
[2, 3, 4]

4.reduce

reduce的用法如下：

reduce(func, seq)

reduce将二元函数func作用于seq序列，首先func作用于的序列的前两个元素，得到func的返回值和第三个元素再被func作用，直到完成整个序列。

>>> reduce(lambda a, b: a+b, (1,2,3))
6

5.sorted

>>> help(sorted)

Help on built-in function sorted in module __builtin__:

sorted(...)

sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

传入可迭代对象，返回一个新的排序后的列表，返回的是新对象。

cmp是用于比较的函数，根据key参数进行比较，key是cmp比较的对象，reverse是是否逆序。使用key比使用cmp效率高。

>>> ll = [(1,2), (5,6), (3,4)]

>>> sorted(ll, lambda x,y:cmp(sum(x),sum(y)))

[(1, 2), (3, 4), (5, 6)]

>>> sorted(ll, key=lambda s:sum(s))

[(1, 2), (3, 4), (5, 6)]

忽略大小写的字符串的列表排序：

>>> def cmp_ignore_case(s1, s2):

return cmp(s1.upper(), s2.upper())

>>> ls = ['Ab', 'aa']

>>> sorted(ls, cmp = cmp_ignore_case)

['aa', 'Ab']

>>> sorted(ls)

['Ab', 'aa']

list对象有自己的排序函数，用法同sorted差不多，排序后的对象仍是原来的对象。

>>> help(list.sort)

Help on method_descriptor:

sort(...)

L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;

cmp(x, y) -> -1, 0, 1

5.偏函数

比如add(a,b) 函数，大量情况下，a=1，会有很多add(1,x)的调用，每次传入参数1，很麻烦，如何简化呢，这就是偏函数的功能。python通过functools.partial模块实现。

>>> from operator import add
>>> add1 = partial(add, 1)
>>> add1(1)
2

6.闭包

函数嵌套中，内部函数中引用了外部函数内定义的局部变量，并且外部函数返回了内部函数的引用，那么内部函数就成了闭包。闭包的__closure__属性保存了外部函数中的变量。

>>> def func():
a,b = 1,2
def clo(x):
print locals()
return x*a,x*b
return clo
>>> a = func()
>>> a.__closure__[0].cell_contents
1
>>> a.__closure__[1].cell_contents
2

看另一个例子：

def counter(start_at=0):
count = [start_at]
def incr():
count[0] += 1
return count[0]
return incr
>>> clo = counter(5)
>>> clo()
6
>>> clo()
7