Python廖雪峰--函数式编程

函数是python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

而函数式编程，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

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

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

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

1.高阶函数

高阶函数(Higher-order function)。

①变量可以指向函数

以Python内置的求绝对值的函数abs(为例，调用该函数用以下代码：

abs(-10)

但是如果只写abs就会报错。可见，abs(-10)是函数调用，而abs是函数本身。要获得函数调用结果，我们可以把结果赋值给变量:

x = abs(-10)

但是，如果吧函数本身赋值给变量呢？

f = abs

结论：函数本身也可以赋值给变量，即：变量可以指向函数。

如果一个变量指向了一个函数，那么，可否通过该变量来调用这个函数？用代码验证一下：

f = abs
x = f(-10)  // x = 10

成功！说明变量f现在已经指向了abs函数本身。直接调用abs()函数和调用变量f()完全相同。

②函数名也是变量

函数名其实就是指向函数的变量！对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！

③传入函数

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

一个最简单的高阶函数：

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

2.map/reduce

①map

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

举例说明，比如我们有一个函数f(x) = x^2,要把这个函数作用在一个list[1,2,4,5,3,6,7,8]上，就可以用map实现：

def f(x):
    return x * x

r = map(f, [1,2,3,4,5,6,7,8,9])

//list(r)  = [1,4,9,16,25,36,49,64,81]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list.

map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)= x^2,还可以计算任意复杂的函数，比如，把这个list所有数字转化为字符串。

②reduce

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

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

3.filter

Python内建的filter()函数用于过滤序列。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

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

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

把一个序列中的空字符串删掉，可以这么写：

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
#结果：['A', 'B', 'C']

可见用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

4.排序算法

排序也是程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但是如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的比较必须通过函数抽象出来。

sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

sorted([36, 5, -12, 9, -21], key = abs)  //按照绝对值大小进行排序
[5,9,-12,-21,36]

key指定的函数将作用于list的每一元素上，并根据key函数返回的结果进行排序。

默认情况下，对字符串排序，是按照ASC||的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能用一个key函数把字符串映射为忽略大小写排序即可。忽略大小写来比较两个字符串，实际上就是先把字符串都变成大写(或小写)，再比较。这样，我们给sorted传入key函数，即可实现忽略大小写的排序：
 

sorted(['A', 'bob', 'D', 'crash'], key = str.lower)

要进行反向排序，不必改动key函数，可以传入第三个参数reverse = True:

sorted(['A', 'bob', 'D', 'crash'], key = str.lower, reverse = True)

从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。

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)

调用f时，才真正计算求和的结果：

f()

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum中的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为"闭包(Closure)"的程序结构拥有极大的威力。另外，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数。

闭包(Closure)

(接上文)注意到返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，所以，闭包用起来简单，实现起来可不容易。

另一个需要注意的问题是，返回的函数并没有立刻执行，而是直到调用了f()才执行。

！！！返回闭包时牢记一点：返回函数不要印油任何循环变量，或者后续会发生变化的变量。

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变

nonlocal

使用闭包，就是用内层函数引用了外层函数的局部变量。如果只是读外层变量的值，我们就会发现返回的闭包函数调用一切正常；但是，如果对外层变量赋值，由于Python解释器会把x当作函数fn()的局部变量，它会报错。

加上nonlocal x的声明后，解释器会把x看做外层函数的局部变量，它已经被初始化了，可以正确计算了。

！！！使用闭包时，对外层变量赋值前，需要先使用nonlocal声明该变量不是当前函数的局部变量。

6.装饰器

由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数.函数对象有一个_name_属性，可以拿到函数的名字：

f._name_

现在，假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为"装饰器"(decorator)。

本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：

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

观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。我们要借助Python的@语法，把decorator置于函数的定义处：

@log
def now():
    print('2015-3-25')

调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志：

call now():

2015-3-25

把@log放到now()函数的定义处，相当于执行了语句：

now = log(now)

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

wrapper()函数的参数定义是(*args, **kw)，因此wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。如果decorator本身需要传入参数，那就需要编写一个返回decorator的敢接函数。一个完整的decorator的写法如下：

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func._name_)
        return func(*args, **kw)
    return wrapper

7.偏函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数(Partial function)。要注意，这里的偏函数和数学意义上的偏函数不一样。在介绍函数参数的时候，我们讲到，通过，设定参数的默认值，可以降低函数调用的难度。而偏函数也可以做到这一点。举例如下：

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换.

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

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

假设要转换大量的二进制字符串，每次都传入int(x, base = 2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base = 2):
    return int(x, base)

这样，我们转换二进制就非常方便了。

functool.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2:

        

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

所以，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住(也就是设置默认值)，返回一个新的函数，调用这个新函数会更简单。注意到上面的新的int2()函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其它值：

int2('1245',10)

最后，创建偏函数时，实际上可以接收函数对象、*args和**kw这三个参数，当传入：

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

实际上固定了int()函数的关键字参数base，也就是：int2('10010')

相当于：

kw = {'base': 2}

int('10010', **kw)

当传入

max2 = functools.partial(max, 10)

实际上会把10作为*args的一部分自动加到左边，也就是：max2(5,6，7)

相当于：

args =  (10, 5, 6, 7)

max(*args)

结果为10