函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

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

Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

---

高阶函数

变量可以指向函数

以Python内置的求绝对值的函数abs()为例：
如果只写abs

>>> abs
<built-in function abs>

abs(-10)是函数调用，而abs是函数本身。
如果把函数本身赋值给变量呢？

>>> f = abs
>>> f
<built-in function abs>

结论：函数本身也可以赋值给变量，即：变量可以指向函数。
如果一个变量指向了一个函数，还可以通过这个变量调用这个函数：

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

变量f已经指向了abs函数本身
其实函数名也是一个变量，它指向了一个可以计算绝对值的函数，可以修改abs只想其他对象，再像调用abs函数那样调用就会报错，因为abs变量已经不是求绝对值的函数了：

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

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。

注：由于abs函数实际上是定义在builtin模块中的，所以要让修改abs变量的指向在其它模块也生效，要用builtin.abs = 10。

传入函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个简单的高阶函数：

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

当调用add(-5, -6, abs)时，参数x, y和f分别接收-5,6和abs，函数就会执行f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
验证：

>>> add(-5, -6, abs)
11

高阶函数就是函数参数可以接收其他函数的函数。

map/reduce

map

map()函数：接收两个参数，第一个是函数，第二个是一个序列，map()函数将传入的函数依次作用于序列的每个元素，并把结果作为新的list返回。如：
把一个函数f(x)=x²作用于list[1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以这样写：

>>> 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]

实际运行原理：

Paste_Image.png

在比如说，把一个list中所有数字转换成字符串：

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

reduce

reduce()函数也是接收两个参数，第一个参数是含有两个参数的函数名，第二个参数是一个序列，函数功能是函数首先作用于前两个参数，然后将返回结果作为自己的第一个参数，将后一个元素作为自己的第二个参数进行计算，知道序列结束。如：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
用reduce()函数实现数列求和：

>>> def add(x, y)
:...    return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

用reduce()函数把序列[1, 3, 5, 7, 9]变换成整数13579：

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

修改一下，配合map()函数，写一个把str转换成int的函数：

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))

练习

1.利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']。

2.Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积。

练习1：

l = ['adam', 'LISA', 'barT']
def f(s):
    return s[0:1].upper()+s[1:].lower()
l = map(f, l)
print l

练习2：

def mulit(x, y):
    return x * y
def prod(l):
    return reduce(mulit, l)

filter

filter()函数用于过滤序列，和map()函数类似，filter()函数也是接收两个参数，第一个是一个函数名，第二个是一个序列，不同的是，filter()根据传入的函数依次作用于序列中每个元素的结果返回值是True还是False决定保留还是丢弃该元素。例如，在一个list中，删除偶数，只保留奇数：

def is_odd(n):
    return n % 2 == 1
filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]) #结果：[1, 5, 9, 15]

把一个序列中的空字符串删掉，可以这样写：
注：strip函数是删除左侧和右侧的空白字符（\r、\n、\t）

def not_empty(s):
    return s and s.strip() #空字符串返回结果为False
filter(not_empty, ['A', '', 'B', None, 'C', ' ']) #结果：['A', 'B', 'C']

练习：
请尝试用filter()删除1~100的素数。

def is_sushu(x):
    if x == 1:
        return True
    for i in range(2,x/2+1):
        if x % i == 0:
            return True
    return False
l = range(1,101)
l = filter(is_sushu, l)
print l

sorted

排序算法
对于排序算法，核心是比较两个元素的大小，如果是数字，可以直接比较，但是如果是字符串或者是两个dict比较，就不可以直接比较了，所以，通常规定，对于两个元素x和y，如果认为x < y，则返回-1，如果认为x == y，则返回0，如果认为x > y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。
Python内置有一个sorted()函数可以对list进行排序：

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

sorted()函数还是一个高阶函数，它还可以接收一个比较函数来自定义排序。比如，如果需要倒序排列，就可以自定义一个reversed_cmp()函数：

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

调用sorted()函数传入reversed_cmp()参数就可以实现倒叙排序：

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

再看一个字符串排序的例子：

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

默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。

现在，修改这个函数，实现忽略大小写，按字母表的顺序排序，只要定义出忽略大小写的比较算法就可以了：

def cmp_ignore_case(s1, s2):
    u1 = s1.upper()
    u2 = s2.upper()
    if u1 < u2:
        return -1
    if u1 > u2:
        return 1
     return 0

调用sorted()函数，传入上边的函数名就可以实现忽略大小写的排序了：

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

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果返回。
比如，定义一个可变参数的求和函数：

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

如果不需要立即执行函数，而是先保存起来，后边根据需要再执行，就可以使用返回求和的函数了：

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()
25

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，sum函数所需要的参数和变量都保存在返回的函数中（可以理解为封装保存到一个包中），这种程序结构称为闭包（Closure）。

当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的调用结果互不影响。

闭包

在返回函数时，返回的函数中还使用了原来函数的局部变量，但是当函数返回后局部变量都已经被释放了，所以，闭包的使用并不简单

此外，返回的函数并没有立刻执行，而是直到调用了f()才执行。如：

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

在上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了。
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果是：

>>> f1()
9
>>> f2()
9
>>> f3()
9

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为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）

当我们把函数当成参数传入函数时，有些比较简单的函数可以不需要显示定义函数，直接传入匿名函数。
在Python中，对匿名函数提供了有限支持。
以map()函数为例，计算f(x)=x²时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

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

匿名函数lambda x: x * x实际上就是：

def f(x): 
    return x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数，后面的表示返回值。

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

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。

此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

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

同样，也可以把匿名函数作为返回值返回，比如：

def build(x, y): 
    return lambda: x * x + y * y

Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。

装饰器

函数也是一个对象，而且函数对象可以赋值给变量，然后通过变量可以调用函数：

>>> def now():
...    print '2013-12-25'
...
>>> f = now
>>> f()
2013-12-25

函数对象有一个name属性，可以拿到函数的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

装饰器：在代码运行期间动态增加功能的方式。比如，要在增强now()函数的功能，在调用前后自动打印日志，但是又不修改now()函数的定义：
decorator1.py

def log(func):
    def wrapper(*args, **kw): #定义返回函数
        print 'call %s():' % func.__name__ #打印日志
        return func(*args, **kw)
    return wrapper 返回函数内部定义的函数

@log #在now()函数定义处，相当于执行了now = log(now)
def now():
    print '2016.10.05'

now() #调用now()函数

使用python decorator1.py执行得到的结果是：
call now():
2016.10.05

本质上，decorator就是一个返回函数的高阶函数，log()函数直接返回一个自己内部定义的函数wrapper()函数，wrapper()函数内部首先打印了日志，然后返回了log()函数传入的函数，当调用now()函数时，相当于执行了log(now)()函数，log(now)函数首先打印了日志，然后返回now函数，返回后就会被执行。

由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数，写出来会更复杂。比如，要自定义log的文本：
decorator2.py

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()

执行python decorator2.py的结果如下：
execute now():
2013-12-25

这里的@log('execute')相当于：now = log('execute')(now)，当执行now()时，相当于执行了log('execute')(now)()

我们来剖析上面的语句，首先执行log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。

以上两种decorator的定义都没有问题，但还差最后一步。因为我们讲了函数也是对象，它有name等属性，但你去看经过decorator装饰之后的函数，它们的name已经从原来的'now'变成了'wrapper'：

>>> now.__name__
'wrapper'

因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的name等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。

Python内置的functools.wraps()就可以修改函数名，而不需要写wrapper.name = func.name：

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

import functools
是导入functools模块。现在，只需记住在定义wrapper()的前面加上@functools.wraps(func)即可。

练习1：
请编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。

练习2：
能否写出一个@log的decorator，使它既支持：

@log
def f(): 
    pass

又支持：

@log('execute')
def f(): 
    pass

练习1：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print 'begin call %s():' % func.__name__
        res = func(*args, **kw)
        print 'end call %s()' % func.__name__
        return res

    return wrapper


@log #fun = log(fun)
def fun():
    print 'I am fun'

fun()
print fun.__name__ #因为加上了@functools.wraps(func)，所以函数fun的名字还是fun，如果注释掉@functools.wraps(func)，函数名会变成wrapper

练习2：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import functools

def log(text):
    if callable(text):
        func = text
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print 'call %s():' % func.__name__
            return func(*args, **kw)
        return wrapper
        
    else:
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print '%s %s():' % (text, func.__name__)
                return func(*args, **kw)
            return wrapper
        return decorator




@log
def func1():
    print 'func1 no paramerator'


@log('excute')
def func2():
    print 'func2 with paramerator'

func1()
func2()

偏函数

int()函数可以把字符串转换呈整数，当仅传入字符串时，int()函数默认按十进制转换，int()函数还有一个默认的参数base，此参数说明按几进制转换，默认值是10：

>>> int('12345')
12345
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

如果要多次调用此函数转换二进制的字符串，每次调用都要传入base参数，非常麻烦，所以，我们可以定义一个新函数int2()，默认把base=2传入，然后就可以直接调用int2()函数进行转换了：

>>> def int2(x, base=2)
...    return int(x, base)
>>> int2('1000000')
64
>>> int2('1010101')
85

这样写好像还是不够简洁，Python的functools模块还提供了一个函数functools.partial()，不需要自己定义int2()函数，可以直接生成。使用partial()函数需要传入两个参数，第一个是函数名，第二个是默认参数：

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

所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

虽然我们创建了一个新的函数int2()设置了一个默认值base=10，但是我们依然可以在调用int2()函数时为base传入其他值：

>>> int2('1000000', base=10)
1000000

其实，partial()函数可以接收函数对象、args和kw三个参数，partial()函数会把args和kw的值当作第一个参数（函数）的参数
例如，当传入：int2 = functools.partial(int, base=2)时，相当于：

kw = { base: 2 }
int('10010', **kw)

当传入：max2 = functools.partial(max, 10)时，实际上会把10作为*args的一部分自动加到左边，max2(5, 6, 7)也就是：

args = (10, 5, 6, 7)
max(*args)

end