Python函数式编程

学习资源来源：慕课网Python进阶

函数可接收函数作为参数

def function(a,b,f)
	return f(a)+f(b)
fuction(-1,5,abs)

map()

接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

map(abs,[-1,2,-3,4])

得到[1,2,3,4]

reduce()

接收一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

reduce()还可以接收第3个可选参数，作为计算的初始值。

def f(a,b):
    return a+b
reduce(f,[1,2,3,4],10)

得到20

filter()

接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

def f(x)
    return x%2==1
filter(f,[1,2,3,4])

得到[1,3]

sorted()

可对list进行排序。
接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

sorted([36, 5, 12, 9, 21])

得到[5, 9, 12, 21, 36]

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

得到['Credit', 'Zoo', 'about', 'bob']

def f(x,y):
    if(x>y):
        return -1
    if(x<y):
        return 1
    if(x==y)
        return 0
sorted([1,3,2,4],f)

返回函数

返回函数可以把一些计算延迟执行，可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

def calc_prod(lst):
    def function():
        def f(x,y):
            return x*y
        return reduce(f,lst,1)
    return function
f = calc_prod([1, 2, 3, 4])
print f()

匿名函数

接收函数做参数，有些时候，我们不需要显式地定义函数，直接传入匿名函数更方便。关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])

得到[1, 4, 9, 16, 25, 36, 49, 64, 81]

装饰器decorator

无参数decorator

import time
def performance(f):
    def fn(*args,**kw): #利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用
        t1=time.time()
        r=f(*args,**kw) #运行了f函数
        t2=time.time()
        print 'call %s() in %fs'% (f.__name__, (t2 - t1))
        return r
    return fn
@performance           #@语法，这样可以避免手动编写factorial = performance(factorial) 这样的代码
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

带参数decorator

import time
def performance(unit):
    def pref_decorater(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 pref_decorater
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

functools

import functools
def log(f):
    @functools.wraps(f)        #将f的属性复制给wrapper
    def wrapper(*args, **kw):  #由于使用了*args,**kw,无法复制参数名
        print 'call...'
        return f(*args, **kw)
    return wrapper
import time, functools
def performance(unit):
    def pref_decorater(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)
            return f
        return wrapper
    return pref_decorater
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial.__name__

decorator还改变了函数的__name__、__doc__等其它属性。如果要让调用者看不出一个函数经过了@decorator的“改造”，就需要把原函数的一些属性复制到新函数中。

偏函数

当一个函数有很多参数时，调用者就需要提供多个参数。如果减少参数个数，就可以简化调用者的负担。

functools.partial帮助我们创建一个偏函数。

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

等同于

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