Python的函数式编程-传入函数、排序算法、函数作为返回值、匿名函数、偏函数、装饰器

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
传入函数
函数的本身也可以作为参数。
Python内建的mapreduce的函数。（来源于谷歌的，后来被道格这家伙开源了，成为当今处理大数据最火热的hadoop中的计算模型---MapReduce）
我们先看map。

map()

函数接收两个参数，一个是函数，一个是序列，

map

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

#使用map（）完成平方的计算
def f(x):
return x*x
l = [1,2,3,4,5,6,7,8]
print map(f, l)  #[1, 4, 9, 16, 25, 36, 49, 64]

请注意我们定义的函数

f

。当我们写

f

时，指的是函数对象本身，当我们写

f(1)

时，指的是调用f函数，并传入参数1，期待返回结果1。

因此，

map()

传入的第一个参数是

f

，即函数对象本身。

像

map()

函数这种能够接收函数作为参数的函数，称之为高阶函数（Higher-order function）。

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

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

#使用reduce完成一个求和计算
def add(x,y):
return x+y
print reduce(add ,l) #36

#使用mapreduce实现将数字字符串转换为整数
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))
print str2int('12345')

排序算法

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。
通常规定，对于两个元素

x

和

y

，如果认为

x < y

，则返回

-1

，如果认为

x == y

，则返回

0

，如果认为

x > y

，则返回

1

，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。
Python内置的

sorted()

函数就可以对list进行排序。

#自定义平排序规则，对数据从大到小排序
def myOrder(x , y):
if x > y:
return -1
elif x< y:
return 1
else: return 0
print sorted(l, myOrder)

函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

#一个求和函数，将函数作为返回值
def laz_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum

ff = laz_sum(*l) #<function add at 0x021448B0>
print ff() #36

在这个例子中，我们在函数

lazy_sum

中又定义了函数

sum

，并且，内部函数

sum

可以引用外部函数

lazy_sum

的参数和局部变量，当

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

的调用结果互不影响。

匿名函数
当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
在Python中，对匿名函数提供了有限支持。还是以

map()

函数为例，计算f(x)=x2时，除了定义一个

f(x)

的函数外，还可以直接传入匿名函数：
#使用匿名函数实现平方计算
print map(lambda x:x*x,l)

匿名函数

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

装饰器
由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。
函数对象有一个

__name__

属性，可以拿到函数的名字。
现在，假设我们要增强

now()

函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改

now()

函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。
#实现一个装饰器，打印日志文件

def log(func):
def wrapper(*args,**kw):
print '运行%s()方法:'% func.__name__
return func(*args, **kw)
return wrapper
@log
def now():
print "2014-11-13"

now() #调用

观察上面的

log

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

把

@log

放到

now()

函数的定义处，相当于执行了语句：

now = log(now)

wrapper()

函数的参数定义是

(*args, **kw)

，因此，

wrapper()

函数可以接受任意参数的调用。在

wrapper()

函数内，首先打印日志，再紧接着调用原始函数。

因为我们讲了函数也是对象，它有

__name__

等属性，但你去看经过decorator装饰之后的函数，它们的

__name__

已经从原来的

'now'

变成了

'wrapper'

：

>>> now.__name__
'wrapper'

因为返回的那个

wrapper()

函数名字就是

'wrapper'

，所以，需要把原始函数的

__name__

等属性复制到

wrapper()

函数中，否则，有些依赖函数签名的代码执行就会出错。

Python内置的

functools.wraps

就是干这个事的，所以，一个完整的decorator的写法如下：

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)

即可。

偏函数
Python的

functools

模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不一样。
主要作用：

functools.partial

的作用就是，把一个函数的某些参数（不管有没有默认值）给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
例如int()默认是将一个字符串转化为十进制的整数，那如果我要默认转换为二进制的呢？
以直接使用下面的代码创建一个新的函数

int2

：

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

最后，创建偏函数时，要从右到左固定参数，就是说，对于函数

f(a1, a2, a3)

，可以固定

a3

，也可以固定

a3

和

a2

，也可以固定

a3

，

a2

和

a1

，但不要跳着固定，比如只固定

a1

和

a3

，把

a2

漏下了。如果这样做，调用新的函数会更复杂。