函数是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