Python高阶函数

一、前言

在慕课网完成了廖雪峰老师的《Python入门》与《Python进阶》两门基础课程。在此做一下简单的知识点小结。

二、函数式编程

Python特点：

• 不是纯函数式编程（允许变量存在）；

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

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

• 有限度的支持匿名函数；

高阶函数：

• 变量可以指向函数；

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

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

def add(x,y,f):  
    return f(x)+f(y)  
#14
add(-5,9,abs)  

三、内置高阶函数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'])  

九、装饰器

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

9.1 无参数装饰器

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))  
#call factorial()...  
#3628800  
print factorial(10)  

9.2 带参数装饰器

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  
#[DEBUG] test()...  
#None  
print test()  

利用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