python 高阶函数 map reduce filter sorted 闭包 装饰器

高阶函数英文叫Higher-order function

1.map


map(func, seq,seq.....)

例如： map(lambda x,y:x+y, range(0, 10), range(0, 10))

相当于： map(lambda x, x*2, range(0, 10))

结果：[0, 2, 4, 6, 8....]

用map实现0,100的加法，就显得力不从心了，不过用下面的方法，简单许多。

2.reduce

reduce(func, seq, init)

其中：func 为二元参数的函数，seq 为序列， init是初始值，
每次获取的两个元素为：上次结果 +此次去除元素

例如：reduce(lambda x,y: x+y, range(0, 101), 0)

结果：5050

特性：取上次结果作为参数

map虽然可以同时遍历两个序列，但是两个序列长度不同的时候，就不太‘优雅’了，此时zip 来了

3.zip

zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

例如：zip(l1, l2, l3) (l1 = range(0, 10), l2=range(1, 10, 2), l3=range(0, 10, 2))

特性：zip 可以将不同长度的序列，以最短的序列为标准，构造成元组列表，元组元素来自于各个序列

所以：在使用map进行操作的时候，如果是多个序列，可以先通过zip‘统一化’，然后由函数处理

4.filter

filter(bool_func, seq)

例如: filter(lambda x: x%2 == 0, range(0, 11))

结果：[0, 2, 4, 6, 8, 10]

特性：只有两个参数，一个是返回值为bool类型的函数， 另外一个是待过滤的序列

filter 的参数函数返回的为bool型的， 下面的sorted的函数也大同小异

5.sorted 

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

第一个是可迭代对象，cmp为比较函数，返回0， 1， -1

key用来指定比较关键字，默认为第一项，若是每个元素有多项内容，可以在这里指定

reverse，bool值表示是否逆置

例如：

def reversed_cmp(x, y):
if x > y:
return -1
if x < y:
return 1
return 0
l = [random.randint(0, 100) for i in range(10)]
sorted(l, reversed_cmp)

结果：[85, 73, 68, 51, 46, 35, 29, 24, 8, 0]

5.闭包

闭包是指可以包含自由（未绑定到特定对象）变量的代码块；
这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义（局部变量）。
“闭包” 一词来源于以下两者的结合：要执行的代码块（由于自由变量被包含在代码块中，这些自由变量以及它们引用的对象没有被释放）
  和为自由变量提供绑定的计算环境（作用域）

python 中支持返回值为函数

此时只要是稍加改变就形成了“闭包”

python中实现方法：

函数中内定义函数，内部定义的函数引用了来自外部函数的值，外部函数返回值为内部定义的函数

def lazy_sum(*args):

    def sum():

        ax = 0

        for n in args:

            ax = ax + n

        return ax

    return sum
当只是对外部函数调用，会获得一的返回的函数，此函数持有外部函数变量

注意：被内部函数引用的变量 尽量不要变化，否则，会出现想不到的结果

g

6.装饰器

简单日志装饰器

g

log(func):

def wrapper(*args, **kwargs):

print " call %s " % func.__name__   # 注意func.__name__
为函数，或者对象名

func(*args, **kwargs)

return wrapper

使用：

@log

def now()

print “123”

now()

结果：call now 

   123

基本原理：

执行的时候，先调用装饰函数，然后装饰函数内部进行真实函数的调用

此时 now =log(now)

简单的说装饰器，就是为了在原有功能（代码不修改）基础上，添加新的功能，进行装饰

详细的，如果带有参数，只需在装饰器外加一层处理参数的代码即可

def log(text):

    def decorator(func):

        def wrapper(*args, **kw):

            print '%s %s():' % (text, func.__name__)

            return func(*args, **kw)

      return wrapper

  return decorator
此时 ：now = log('execute')(now)

g

注意，此处就用到了闭包哦