Python学习笔记之【函数式编程】

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。

高阶函数

变量可以指向函数

>>> f = abs
>>> f(-10)
10

函数名也是变量

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

传入函数

一个函数可以接收另一个函数作为参数，这种函数就称之为高阶函数。

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

map函数

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

>>> def f(x):
...     return x * x
...
>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
['1', '2', '3', '4', '5', '6', '7', '8', '9']

reduce函数

把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

'reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)'
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

filter函数

接受一个函数和一个序列，将传入的函数作用于每一个元素，然后根据返回值是True还是False，决定是否保留该元素。

def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 结果: [1, 5, 9, 15]

sorted函数

接收一个比较函数来实现自定义的排序。

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0
>>> sorted([36, 5, 12, 9, 21], reversed_cmp)
[36, 21, 12, 9, 5]

返回函数

函数作为返回值

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

当调用lazy_sum()时，返回的并不是求和结果，而是求和函数：
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function sum at 0x10452f668>

调用函数f时，才真正计算求和的结果：
>>> f()
25

闭包

当函数返回函数时，相关参数和变量都保存在返回的函数中，这种结构称为“闭包”。返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

匿名函数

关键字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]

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x10453d7d0>
>>> f(5)
25

装饰器

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。本质上，decorator就是一个返回函数的高阶函数。

PS：函数对象有一个__name__属性，可以拿到函数的名字(f.__name__)。

def log(func):
    def wrapper(*args, **kw):
        print 'call %s():' % func.__name__
        return func(*args, **kw)
    return wrapper

@log
def now():
    print '2013-12-25'

>>> now()
call now():
2013-12-25

相当于now=log(now)

如果decorator本身需要传入参数，再套一层定义即可。

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print '%s %s():' % (text, func.__name__)
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print '2013-12-25'

>>> now()
execute now():
2013-12-25

相当于now=log('execute')(now)

返回函数的名字是最内层的，所以当前函数的名字会出错。Python内置的functools.wraps能过实现命名，在最内层的函数外加上@functools.wraps(func)即可。

import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print 'call %s():' % func.__name__
        return func(*args, **kw)
    return wrapper
#带参数的decorator
import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print '%s %s():' % (text, func.__name__)
            return func(*args, **kw)
        return wrapper
    return decorator

偏函数

int()函数提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换。

int('12345', base=8)

那如果想要一个转二进制的函数int2()呢？functools.partial可以帮助我们创建一个偏函数，不需要我们自己定义int2()。

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

简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数。创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数。