python进阶一：高阶函数

1、函数式编程：

      python特点：不是纯函数式编程（允许变量存在）；

                              支持高阶函数（可以传入函数作为变量）；

                              支持闭包（可以返回函数）；

                              有限度的支持匿名函数；

       高阶函数：变量可以指向函数；

                           函数的参数可以接收变量；

                           一个函数可以接收另一个函数作为参数；

def add(x,y,f):
	return f(x)+f(y)

add(-5,9,abs)

14

       内置高阶函数map():map函数有两个参数，一个是函数，另一个是列表，返回值为对传入的列表每一个元素执行传入的函数操作得到的列表；

def format_name(s):
    return s.title();
        

print map(format_name, ['adam', 'LISA', 'barT'])

      内置高阶函数reduce():reduce函数也有两个参数，一个是函数，另一个是列表，返回值为对list的每一个元素反复调用函数f，得到最终结果，以下函数为连乘；

def prod(x, y):
    return x*y;

print reduce(prod, [2, 4, 5, 7, 12])

     内置高阶函数filter():filter函数接受函数参数f和列表参数lst，f对lst元素进行判断，返回lst的元素中调用f函数结果为true的元素组成的列表（将不满足f函数条件的元素过滤掉）；

import math

def is_sqr(x):
    return int(math.sqrt(x))*int(math.sqrt(x))==x

print filter(is_sqr, range(1, 101))

     自定义排序函数sorted():sorted函数接受一个列表lst和一个函数参数f，f为自定义的比较lst元素大小的函数，返回值为lst中元素按f函数排列的列表；

def cmp_ignore_case(s1, s2):
    return cmp(s1.lower(),s2.lower())

print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

     返回函数：

def calc_prod(lst):
    def prod(x,y):
        return x*y;
    def g():
        return reduce(prod,lst)
    return g;

f = calc_prod([1, 2, 3, 4])
print f()

      闭包：内层函数使用外层函数的参数，然后返回内层函数；

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
              return j*j;
            return g
        fs.append(f(i))
    return fs

f1, f2, f3 = count()
print f1(), f2(), f3()

       匿名函数：传入函数参数不需要显式定义函数，可以用lambda x:statement     x为参数，statement为对参数执行的语句；

def is_not_empty(s):
    return s and len(s.strip()) > 0

print filter(lambda s:s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

       装饰器：给函数添加新功能，并简化该函数调用；

无参数装饰器示例：

def log(f):
    def fn(*args, **kw): #*args，**kw保证对任意个数参数都能正常调用
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

@log   #调用日志装饰器
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

call factorial()...
3628800

带参数装饰器示例：

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator

@log('DEBUG')#DEBUG为给装饰器传入的参数
def test():
    pass
print test()

执行结果
[DEBUG] test()...
None

利用functool.wraps作用在返回的新函数上，使得调用装饰器以后不改变原函数的信息

import time, functools
def performance(unit):
    def perf_decorator(f):
        @functools.wraps(f)
        def wrapper(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
            print 'call %s() in %f %s' % (f.__name__, t, unit)
            return r
        return wrapper
    return perf_decorator

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial.__name__

偏函数：

functools.partial(f,f的默认参数)  减少需要提供给f的参数

import functools
int2 = functools.partial(int, base=2)
int2('1000000')
64