map(func, list)

map(func, list) 函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

举例说明

比如我们有一个函数a(x)=x*2，要把这个函数作用在一个list [1, 2, 3, 4, 5]上，就可以用map()实现如下:

>>> def a(x):
...     return x * 2
... 
>>> map(a, [1,2,3,4,5]) 
[2, 4, 6, 8, 10]

map传入的第一个参数a为函数，当然你也可以不用map函数实现这功能：

>>> list = []
>>> for i in [1, 2, 3, 4, 5]:
...     list.append(a(i))
... 
>>> print list
[2, 4, 6, 8, 10]

从代码量上来讲，map要精简很多，所以 map() 作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的a(x)=x ＊2 ，还可以计算任意复杂的函数

比如，把这个list所有数字转为字符串：

>>> map(str,[1,2,3,4,5])
['1', '2', '3', '4', '5']
>>>

只需要一行代码，就搞定了。

让我们再看一例：利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。例如：

输入：[‘adam’, ‘LISA’, ‘barT’]

输出：[‘Adam’, ‘Lisa’, ‘Bart’]

作为我个人来说，我可能会先将不规范的英文名全转换在小写然后再通过capitalize()函数，将首字母转换在写，代码如下：

>>> def caps(name):
...     return name.capitalize()
... 
>>> def lowers(name):
...     return name.lower()
... 
>>> map(caps, map(lowers,['adam', 'LISA', 'barT']))
['Adam', 'Lisa', 'Bart']

reduce(function, sequence, starting_value)

reduce(function, sequence, starting_value)：对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用

例如对List求和：

>>> def add(x, y):
...     return x + y
... 
>>> reduce(add, [1, 3, 5, 7, 9])
25
>>> reduce(add, range(1, 11))
55
>>> reduce(add, range(1, 11),20)
75

当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。但是如果要把序列 [1,2,3,4,5,6,7] 变换成整数1234567，reduce就可以派上用场：

>>> def fn(x, y):
...     return x * 10 + y
... 
>>> reduce(fn, [1,3,4,5,6,7])
134567

lamdba

lamda 是一个表达式，本质上可当做一个函数，基本格式：

lambda x,y,z : x+y+z                                    # lambda  参数 : 结果

map(lambda x: x * 2 + 10, foo)                   # map(lambda 参数 : 结果, 输入)

reduce(lambda x, y: x + y, foo)                   # map(lambda 参数 : 结果, 输入)

filter(lambda x: x % 3 == 0, foo)                 # map(lambda 参数 : 结果, 输入)

示例代码：

>>> f = lambda x, y, z: x+y+z
>>> f(1, 3, 5)
9
>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
>>> filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]
>>> 
>>> map(lambda x: x*2, foo)
[4, 36, 18, 44, 34, 48, 16, 24, 54]
>>> 
>>> reduce(lambda x,y: x+y, foo)
139
>>> filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]
>>> print([x for x in foo if x % 3 == 0])
[18, 9, 24, 12, 27]
>>> 
>>> map(lambda x: x*2, foo)
[4, 36, 18, 44, 34, 48, 16, 24, 54]
>>> print([x*2 for x in foo])
[4, 36, 18, 44, 34, 48, 16, 24, 54]
>>> 
>>> reduce(lambda x,y: x+y, foo)
139
>>> print(sum(foo))
139

上面代码中，分别有map，reduce，filter的lambda实现，以及普通的列表循环实现，结果一样。

lambda更简洁，效率更高； 但普通列表循环更清晰，更易理解。