高阶函数

• 变量可以指向函数
• 函数名也是变量
• 传入函数

#变量指向函数
>>> 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)

add(-5, 6, abs)  #返回11

map

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

map(function, list)

map示意图

>>> def f(x):
...     return x * x
...
>>> l = range(11)
>>> map(f, l)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

reduce

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

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, range(1, 11))
55

>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

>>> def str2int(s):
...     def fn(x, y):
...         return x * 10 + y
...     def char2num(s):
...         return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...     return reduce(fn, map(char2num, s))
...
>>> str2int('12345')
12345

#reduce求积
reduce(lambda x,y : x*y, [1,3,5,4,5])

filter

过滤序列。filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

>>> def is_odd(x):
...     return x % 2 == 1
...
>>> filter(is_odd, range(1, 11))
[1, 3, 5, 7, 9]

sorted

作为低阶函数时，为对传入集合排序

>>> sorted([10, 1, 3, 2, 4, 8, 19, 14])
[1, 2, 3, 4, 8, 10, 14, 19]

作为高阶函数时，传入排序函数

def reverse_cmp(x, y):
    if x > y :
        return -1
    if x < y:
        return 1
   if x == y:
       return 0

sorted([23, 21,8,88], reverse_cmp)

通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。

返回函数

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

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function sum at 0x10452f668>
>>> f()
25

闭包

一个函数返回了一个函数.

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

f1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>>> f3()
9
#返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

#如上处理----方法是再创建一个函数，用该函数的参数绑定循环变量当前的值
>>> 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()
>>> f1()
1
>>> f2()
4
>>> f3()
9

匿名函数

关键字lambda表示匿名函数；

lambda x, y : x*y
#冒号前面的x, y表示函数参数, 冒号后面表示函数表达式；
#匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

#匿名函数也是一个对象
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x10453d7d0>
>>> f(5)
25

装饰器

在代码运行期间动态增加函数功能的方式，称之为“装饰器”（Decorator），decorator就是一个返回函数的高阶函数。
借助Python的@语法，把decorator置于函数的定义处。

#例：在函数调用前后自动打印日志，但又不希望修改now()函数的定义
def log(func):
    def wrapper(*args, **kw):
        print 'call %s():' % func.__name__
        return func(*args, **kw)
    return wrapper

#借助Python的@语法，把decorator置于函数的定义处
@log
def now():
    print '2013-12-25'

#如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print '%s %s():' % (text, func.__name__)
            return func(*args, **kw)
        return wrapper
    return decorator
这个3层嵌套的decorator用法如下：

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

#__name__属性经过decorator装饰之后，值已经从原来的'now'变成了'wrapper'，需要解决这个问题！！！方式如下；
#不带参数的
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

偏函数 Partial function

帮助我们在已有函数上创建新的函数，可设定默认参数，简化后续调用；通过functools.partial协助创建；

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('10000')
16