Python基础：09函数式编程
Python支持一些函数式编程的特性。比如lambda、 map()、reduce()、filter()函数。
一：匿名函数与lambda
Python可以用lambda 关键字创造匿名函数。匿名函数不需要以标准的方式来声明（使用def 语句）。作为函数，它们也能有参数。
一个完整的lambda“语句”代表了一个表达式，这个表达式的定义体必须和声明放在同一行。匿名函数的语法如下：
lambda [arg1[, arg2, ... argN]]: expression
参数是可选的，lambda 生成一个可以像其他函数一样使用的函数对象。
比如下面的简单函数：
def true(): return True
对于该函数，可以使用lambda表达式生成等价的函数对象：
>>> lambda :True <function <lambda> at f09ba0>
在上面的例子中，只是简单地用lambda创建了一个函数（对象），但是该函数对象创建完之后就被垃圾回收了。
为了保留住这个对象，将它保存到一个变量中，以后可以随时调用：
>>> true = lambda :True >>> true() True
下面是更多的例子：
def add(x, y): return x + y 等价于 lambda x, y: x + y
def usuallyAdd2(x, y=2): return x+y 等价于 lambda x, y=2: x+y
def showAllAsTuple(*z): return z等价于lambda *z: z
>>> a = lambda x, y=2: x + y >>> a(3) 5 >>> a(3,5) 8 >>> a(0) 2 >>> a(0,9) 9 >>> >>> b = lambda *z: z >>> b(23, 'zyx') (23, 'zyx') >>> b(42) (42,)
二：filter()、map()、reduce()
这些函数提供了在python 中可以找到的函数式编程的特征。lambda 表达式可以很好的和这些函数相结合，因为这些函数都带了一个可执行的函数对象的参数。lambda 表达式提供了迅速创造这个参数的机制。
a：filter(function, iterable)
给定一个对象的序列和一个“过滤”函数，每个序列元素都通过这个过滤器进行筛选，保留函数返回为真的的对象。filter 函数为已知的序列的每个元素调用给定布尔函数function。将经过function处理返回True值的元素添加到一个列表中。返回的对象是一个从原始队列中“过滤后”的列表。
注意：如果iterable是一个字符串或者元组的话，则结果也是同样的类型，否则，结果为一个列表。如果function为None的话，则该函数表现为一个身份函数，也就是该函数会返回，iterable中所有值为True的元素组成的列表。
如果用纯python 编写filter()，它或许就像这样：
def filter(bool_func, seq): filtered_seq= [] for eachItem in seq: if bool_func(eachItem): filtered_seq.append(eachItem) return filtered_seq
例子如下：
>>> alist = [1,2,3,0,4,5] >>> filter(None, alist) [1, 2, 3, 4, 5] >>> filter(lambda x: True,'abcdefg') 'abcdefg' >>> filter(lambda x: True,(1,2,3,4,5)) (1, 2, 3, 4, 5)
注意，如果function不是None的话，则filter(function,iterable)等价于：[item for item in iterable if function(item)]。如果function为None的话，则它等价于[itemfor item in iterable if item]。比如求一个随机列表中所有奇数的方法：
allNums = [] for eachNum in range(9): allNums.append(randint(1,99)) print filter(lambda n: n%2, allNums)
等价于：
allNums = [] for eachNum in range(9): allNums.append(randint(1,99)) print [n for n in allNums if n%2]
b：map(function, iterable, ...)
将function应用到iterable中的每个元素上，并返回一个由返回值组成的列表。如果给出了多个iterable参数，则function必须具有相同数目的参数，并且该function会并行的迭代所有iterable中的元素。如果其中一个iterable比较短，则假设用None将其扩展。
如果function为None，则如果给出了多个iterable，那map返回一个元素为元组的列表，其中的元组包含所有iterable的相应元素。
该函数的结果只能是列表。
如果要用python 编写一个简单的只有一个iterable的map（），代码如下：
def map(func, seq): mapped_seq= [] for eachItem in seq: mapped_seq.append(func(eachItem)) return mapped_seq
例子如下：
>>> map((lambda x: x+2), [0, 1, 2, 3, 4, 5]) [2, 3, 4, 5, 6, 7] >>> map(None, (1,2,3,4),'abc') [(1, 'a'), (2, 'b'), (3, 'c'), (4, None)] >>> map(lambda x: x**2, range(6)) [0, 1, 4, 9, 16, 25] >>> map(lambda x, y: x + y, [1,3,5], [2,4,6]) [3, 7, 11] >>> map(lambda x, y: (x+y, x-y), [1,3,5],[2,4,6]) [(3, -1), (7, -1), (11, -1)] >>> map(None, [1,3,5], [2,4,6]) [(1, 2), (3, 4), (5, 6)]
c：reduce(function, iterable[, initializer])
function是有两个参数的函数，它会持续的对iterable中，从左到右的每个元素进行处理，从而会将iterable中所有元素reduce为一个值。比如reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])，将会计算((((1+2)+3)+4)+5)。左参数x是累计计算的结果，右参数y是iterable中的下一个元素。如果给定initializer参数值的话，则它会是第一个左参数，iterable中的第一个元素是第一个右参数。如果initializer没有给定值，则第一个左参数为iterable[0]，第一个右参数为iterable[1]。
reduce的类Python代码实现如下：
def reduce(function, iterable, initializer=None): it = iter(iterable) if initializeris None: try: initializer= next(it) except StopIteration: raiseTypeError('reduce() of empty sequence with no initial value') accum_value =initializer for x in it: accum_value= function(accum_value, x) return accum_value
例子如下;
>>> print 'the total is:', reduce((lambda x,y:x+y), range(5)) the total is: 10
三：偏函数
偏函数类似于默认参数，可以降低函数调用的难度。举例如下：
int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：
>>> int('12345') 12345
但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换：
>>> int('12345', base=8) 5349 >>> int('12345', 16) 74565
假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：
def int2(x, base=2): return int(x, base)
这样，我们转换二进制就非常方便了：
>>> int2('1000000') 64 >>> int2('1010101') 85
functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：
>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85
所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
注意到上面的新的int2函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值：
>>> int2('1000000', base=10) 1000000
最后，创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入：int2 = functools.partial(int, base=2)实际上固定了int()函数的关键字参数base，也就是：
int2('10010')
相当于：
kw = { base: 2 }
int('10010', **kw)
当传入：
max2 = functools.partial(max, 10)
实际上会把10作为*args的一部分自动加到左边，也就是：
max2(5, 6, 7)
相当于：
args = (10, 5, 6, 7)
max(*args)
结果为10。
参考：http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386819893624a7edc0e3e3df4d5d852a352b037c93ec000
