文章目录
- 函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数!
1. 高阶函数
- 英文名:Higher-order function
1.1 变量可以指向函数
- 以内置的求绝对值函数
abs()
为例:
>>> abs(-10)
10
# 如果只写abs呢
>>> abs
<build-in function abs>
# 要获得函数调用结果,可以把结果赋值给变量
>>> x = abs(-10)
>>> x
10
# 如果把函数本身赋值给变量呢
>>> f = abs
>>> f
<build-in function abs> # 可见变量可以指向函数
# 同时调用函数和调用变量是一样的
>>> f = abs
>>> f(-10)
10
1.2 传入函数
- 既然变量可以指向函数,函数的参数可以接受变量,那么一个函数就可以接受另外一个函数作为变量,这种函数就叫做高阶函数;
# 一个简单的高阶函数
def add(x, y, f):
return f(x) + f(y)
# 调用此高阶函数
>>> add(-5, 6, abs)
11
1.3 map/reduce
1.3.1 map()
map()
函数接受两个参数,一个是函数,另外一个是Iterable
,map
将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator
返回;- 我们有一个函数
,要把这个函数作用在一个list
[1, 2, 3, 4, 5, 6, 7, 8, 9]
:
# 用map()方法实现
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r) # 由于r是一个Iterator,是惰性序列,故通过list()函数把整个序列算出来,并返回一个list
[1, 4, 9, 16, 25, 36, 49, 64, 81]
# 同时也可以用for循环方法实现
>>> L = []
>>> for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
L.append(f(n))
print(L)
# 这种方法比较麻烦,而map一行代码就可以实现
map()
函数还可以计算复杂的函数,比如,将这个list所有数字转为字符串:
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']
1.3.2 reduce()
reduce()
把一个函数作用在一个序列[x1, x2, x3, ...]
上,这个函数必须接受两个参数,reduce
继续把结果和序列的下一个元素做累积计算,其效果就是:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
- 比方说对一个序列求和:
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
- 当然求和可以用
sum()
函数,没必要reduce()
,但将序列[1, 3, 5, 7, 9]
变换成整数13579
,就需要reduce
函数:
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579
- 如果考虑到字符串
str
也是一个序列,对上面稍加修改,配合map()
,就可以写出把str
转为int
的函数:
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> def char2num(s):
... digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
... return digits[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579
- 整理成一个
str2int
函数:
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return DIGITS[s]
return reduce(fn, map(char2num, s))
- 还可以用
lambda
函数进一步简化:
from functools import reduce
DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def char2num(s):
return DIGITS[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
# lambda 函数的用法在后面介绍
1.3.3 练习1
- 利用
map()
函数,把用户输入的不规范的英文名字,变为首字母大写,其他小写的规范名字。输入:['adam', 'LISA', 'barT']
,输出:['Adam', 'Lisa', 'Bart']
:
>>> def normalize(name):
... return name[0].upper() + name[1:].lower()
>>> L1 = ['adam', 'LISA', 'barT']
>>> L2 = list(map(normalize, L1))
>>> print(L2)
['Adam', 'Lisa', 'Bart']
1.3.4 练习2
- Python提供的
sum()
函数可以接受一个list并求和,请编写一个prod()
函数,可以接受一个list并利用reduce()
求积:
>>> from functools import reduce
>>> def prod(L):
... def fn(x, y):
... return x * y
... return reduce(fn, L)
>>> prod([1, 3, 5, 7, 9])
945
1.3.5 练习3
- 利用
map
和reduce
编写一个str2float
函数,把字符串'123.456'
转换成浮点数123.456
:
>>> from functools import reduce
# 方法一
>>> from math import pow
>>> def str2float(s):
... def fn(x, y):
... length = len(y)
... return int(x) + int(y)/pow(10, length)
... return reduce(fn, list(map(str, s.split('.'))))
...
>>> print(str2float('123.456'))
123.456
# 方法二
>>> def str2float(s):
... def fn(x, y):
... return float(x + '.' + y)
... return reduce(fn, list(map(str, s.split('.'))))
...
>>> print(str2float('123.456'))
123.456
1.4 filter
- python内建的
filter()
函数用来过滤数列,和map()
一样,filter()
也接受一个函数和一个数列,只不过不用的是,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()
函数返回的是一个Iterator
,惰性序列,所以需要list()
函数获得所有结果并返回list
1.4.1 用filter()
求素数
- 计算素数的一个方法是埃氏筛法,算法说明如下:
- 列出从
2
开始的所有自然数,构成一个序列:
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, … - 取序列的第一个数
2
,它一定是素数,然后用2
把序列的2
的倍数筛掉:
3, 5, 7, 9, 11, 13, 15, 17, 19, … - 取新序列的第一个数
3
,它一定是素数,然后用3
把序列的3
的倍数筛掉:
5, 7, 11, 13, 17, 19, … - 取新序列的第一个数
5
,然后用5
把序列的5
的倍数筛掉:
7, 11, 13, 17, 19, … - 不断筛选下去,就可以得到所有的素数,下面用Python来实现这个算法:
- 列出从
# 构造一个从3开始的奇数序列,注意这是一个生成器,并且是一个无限序列;
>>> def _odd_iter():
... n = 1
... while True:
... n = n + 2
... yield n
...
# 定义一个筛选函数;
>>> def _not_divisible(n):
... return lambda x: x % n > 0
...
# 定义一个生成器,不断返回下一个素数;
>>> def primes():
... yield 2 # 生成器先返回第一个素数2,然后,利用filter()不断产生筛选后的新的序列;
... it = _odd_iter()
... while True:
... n = next(it)
... yield n
... it = filter(_not_divisible(n), it)
...
# 由于primes()也是一个无限序列,所以调用时需要设置一个退出循环的条件;
>>> for n in primes():
... if n < 1000:
... print(n)
... else:
... break
...
1.4.2 练习
- 回数是指从左向右读和从右向左读都是一样的数,例如
12321
,909
。请利用filter()
筛选出回数:
>>> def is_palindrome(n):
... return str(n) == str(n)[::-1]
...
>>> output = filter(is_palindrome, range(1, 1000))
>>> print('1-1000:', list(output))
1-1000: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]
1.5 sorted
- 无论是冒泡排序还是快速排序,排序的核心是比较两个元素的大小,如果是数字,可以直接比较大小,但如果是字符串或者两个dict呢,python内置的
sorted()
函数就可以对list就行排序:
# 对list进行排序:
>>> sorted([36, 5, -12, -24])
[-24, -12, 5, 36]
# 同时也是一个高阶函数,可以接受一个key函数来实现自定义的排序,例如按绝对值大小进行排序:
>>> sorted([36, 5, -12, -24], key = abs)
[-24, -12, 5, 36]
- 字符串排序的例子:
# 默认情况下,是根据ASCII的大小进行排序,由于'Z'<'a',所以:
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
# 通过将所有字符串都变成大写或者小写,来实现忽略大小写的排序:
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
# 进行反向排序,传入reverse=True即可:
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']
练习1
- 假设我们用一组tuple表示学生名字和成绩:
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
请用sorted()
对上述列表分别按名字排序:
>>> L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)
>>> def by_name(t):
... return t[0]
...
>>> L2 = sorted(L, key=by_name)
>>> print(L2)
[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]
练习2
- 再按成绩从高到低排序:
>>> L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
>>> def by_score(t):
... return -t[1]
...
>>> L2 = sorted(L, key=by_score)
>>> print(L2)
[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]
2. 返回函数
2.1 函数作为返回值
- 高阶函数除了可以接受函数作为参数外,还可以将函数作为结果值返回;
- 例如实现一个可变参数的求和:
# 通常情况下,求和函数这样定义:
>>> 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
...
>>> f = lazy_sum(1, 2, 3) # 当调用lazy_sum时,返回的并不是求和结果,而是求和函数;
>>> f
<function lazy_sum.<locals>.sum at 0x0000022D10582598>
>>> f() # 调用函数f时,才真正计算求和的结果;
- 此例中,在函数
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 # f1()和f2()的调用结果互不影响;
False
2.2 闭包
- 注意到返回的函数在其定义内部引用了局部变量
args
,当一个函数返回了另外一个函数后,其内部的局部变量还被新函数引用; - 另外注意返回的函数并没有立刻执行,而是直到调用了
f()
后才执行,例如:
def count():
fs = []
for i in range(1, 4):
def f():
return i*i
fs.append(f)
return fs
f1, f2, f3 = count()
# 每次循环,都创建了一个函数,返回这三个函数
- 可能以为调用
f1()
,f2()
,f3()
的结果是1
,4
,9
,但实际结果是:
>>> f1()
9
>>> f2()
9
>>> f3()
9
- 全部都是
9
!原因就在于返回的函数引用了变量i
,但它并非立刻执行。等到3个函数都返回时,它们所引用的变量i
已经变成了3
,因此最终结果为9
。 - 返回闭包时牢记:返回函数不要引用任何循环变量,或者后续会变化的变量
- 如何引用循环变量呢,方法就是再创建一个函数,用该函数的参数绑定当前循环变量的值,无论该循环变量后期如何变化,已绑定到函数参数的值不变:
def count():
def f(j):
def g():
return j * j
return g
fs = []
for i in range(1, 4):
fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
return fs
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9
- 缺点是代码较长,可利用
lambda
函数缩短代码。
2.3 练习
- 利用闭包返回一个计数器函数,每次调用它返回递增整数:
def createCounter():
i = [0]
def counter():
i[0] = i[0] + 1
return i[0]
return counter
counterA = createCounter()
print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5
counterB = createCounter()
if [counterB(), counterB(), counterB(), counterB()] == [1, 2, 3, 4]:
print('测试通过!')
else:
print('测试失败!')
Run
3. 匿名函数
- 当传入函数时,有时候并不需要显式的定义函数,直接传入匿名函数更加方便;
# 例如在map()函数中,在计算平方时,除了定义一个f(x)函数外,还可以直接传入匿名函数
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7]))
[1, 4, 9, 16, 25, 36, 49]
- 可以看出匿名函数
lambda x: x * x
实际上就是:
def f(x):
return x * x
- 关键字
lambda
表示匿名函数,冒号前面的x
表示函数参数; - 匿名函数有个限制,就是只能有一个表达式,不用写
return
,返回值就是该表达式的结果; - 同时,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量,再利用变量来调用该函数;
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25
- 同时也可将匿名函数作为返回值返回;
def build(x, y):
return lambda: x * x + y * y
练习
- 请使用匿名函数改造下面的代码:
def is_odd(n):
return n % 2 == 1
L = list(filter(is_odd, range(1, 20)))
print(L)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> L = list(filter(lambda n: n % 2 ==1, range(1, 20)))
>>> print(L)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
4. 装饰器
- 函数对象可以被赋值给变量,所以,通过变量也可以调用该函数:
>>> def now():
... print('2018-11-9')
...
>>> f = now
>>> f()
2018-11-9
函数对象有一个__name__
属性,可以拿到函数的名字:
>>> now.__name__
'now'
>>> f.__name__
'now'
- 加入我们现在想增强
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('2018')
# 调用now()函数,不仅会运行函数本身,还会在运行now()函数前打印一行日志:
>>> now()
call now():
2018
# 把@log放到now()函数的定义处,相当于执行了语句:
now = log(now)
-
由于
log()
是一个decorator,返回一个函数,故,原来的now()
函数任然存在,只是现在同名的now
变量指向了新的函数,即在log()
函数中返回的wrapper()
函数; -
wrapper()
函数的参数定义是(*args, **kw)
,(*args 是非关键字参数,用于元组,**kw 是关键字参数,用于字典)
,因此,wrapper()
函数可以接受任意参数的调用,在wrapper()
函数内,首先打印日志,再紧接着调用原始函数; -
如果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
# 这三层嵌套的decorator用法如下:
@log('execute')
def now():
print('2018')
# 执行结果:
>>> now()
execute now():
2018
- 和两层嵌套的
decorator
相比,3层嵌套的结果是这样的:
>>> now = log('execute')(now)
- 上面的语句,首先执行
log('execute')
,返回的是decorator
函数,再调用返回的函数,参数是now()
函数,返回值最终是wrapper
函数; - 前面也讲了函数也是对象,他也有
__name__
属性,但看经decorator
装饰过的函数:
>>> now.__name__ # 已经由原来的'now'变为现在的'wrapper';
'wrappper'
- 因为最后返回到
wrapper
函数名字就是wrapper
,所以需要把原先的__name__
等属性复制到wrapper
函数中,否则有些依赖函数签名的代码执行就容易出错: - python内置的
functools.wraps
可以完成这个功能,所以一个完整的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
练习
- 设计一个decorator,他可作用于任何函数上,并打印该函数的执行时间:
import time, functools
def metric(fn):
@functools.wraps(fn)
def wrapper(*args, **kw):
start = time.time()
fn(*args, **kw)
end = time.time()
print('%s execute in %s ms' %(fn.__name__, end - start))
return fn(%args, **kw)
return wrapper
5. 偏函数
- 这里的偏函数(partial function)和数学意义上的偏函数不一样
- 在介绍函数参数的时候,我们讲到,通过设定函数参数的默认值,可以降低函数调用的难度,而偏函数也可以做到这一点;
# int()函数可以把字符串转换为整数,当仅传入字符串时,int()函数可以按照默认值进行十进制转换;
>>> int('123456')
123456
# 但int()函数同时还提供额外的base参数,默认值为10,传入base参数,可以做N进制的转换;
>>> int('123456', base = 8)
42798
>>> int('123456', 8)
42798
# 如果要转换大量的二进制字符串,每次都传入int(x, base = 2)很麻烦,于是,我们可以定义一个int2()的函数,默认把base=2传进去;
def int2(x, base = 2):
return int(x, base)
# 这样转换二进制就非常方便了
>>> int2('1000000')
64
>>> int2('1010101')
85
functools.partial
就是帮助我们创建一个偏函数的,不需要我们自定义int2()
,可以直接用一行代码创建一个新的函数int2()
;
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('100000')
32
functools.partial
函数的功能就是把一个函数的某些参数给固定住(就是设置默认值),返回一个新的函数,调用这个新的函数会非常方便;- 注意到上面的
int2
函数,仅仅把base
参数默认值设定为2
,但是在调用时依然可以传入其他参数值:
>>> int2('100000', base=10)
100000
- 最后在创建偏函数时,实际上可以接收函数对象,
*args
和**kw
这3个参数,当传入:
int2 = functools.partials(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