python入门基础总结笔记(4)——函数式编程

学习采用的是廖雪峰老师的python教程，很精彩详细，收获很大，聊表感谢！原文链接：https://www.liaoxuefeng.com/wiki/1016959663602400

目录

高阶函数——map/reduce,filter（过滤）,sorted（排序）返回函数——返回的是函数，闭包匿名函数——lambda装饰器——原函数上附加功能：打印等偏函数——functools.partial创建一个新的函数，固定住原函数的部分参数

1.高阶函数

1.1map/reduce

map

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

举例: 函数f(x)=x^2，要把这个函数作用在一个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]) #r是一个Iterator >>> list(r) #Iterator是惰性序列，通过list()函数计算出来并返回一个list。 [1, 4, 9, 16, 25, 36, 49, 64, 81]

也可用循环的方法：

L = [] for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]: L.append(f(n)) print(L)

map()作为高阶函数，事实上它把运算规则抽象了,能一眼看出代码求什么。比如只用一行代码就可以把这个list所有数字转为字符串：

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

配合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

练习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']

练习2 请编写一个prod()函数，可以接受一个list并利用reduce()求积：

from functools import reduce def prod(L): def mul(x,y): return x*y return reduce(mul,L) #测试 print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9])) if prod([3, 5, 7, 9]) == 945: print('测试成功!') else: print('测试失败!')

练习3 利用map和reduce编写一个str2float函数，把字符串’123.456’转换成浮点数123.456：

def str2float(s): def str2num(a): digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} return digits[a] def sum(x, y): return x * 10 + y n = s.index('.') #求小数点前面有几位数，此处为 3 s1=reduce(sum, map(str2num, s[:n])) s2=reduce(sum, map(str2num, s[n+1:]))/ 10**(len(s)-n-1) return s1+s2 #测试 print('str2float(\'123.456\') =', str2float('123.456')) if abs(str2float('123.456') - 123.456) < 0.00001: print('测试成功!') else: print('测试失败!')

结果：

str2float('123.456') = 123.456 测试成功!

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

练习 回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数：

def is_palindrome(n): s=str(n) #化为字符串形式，方便指定位置 flag=True for x in range(len(s)): if s[x]!=s[len(s)-x-1]: flag=False else:continue return flag #返回值为正时，该数才会留下，其他被滤除 # 测试: output = filter(is_palindrome, range(1, 1000)) print('1~1000:', list(output)) if list(filter(is_palindrome, range(1, 200))) == [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]: print('测试成功!') else: print('测试失败!')

运行结果：

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.3 sorted（排序算法）

Python内置的，sorted()函数就可以对list中的数字和字符串进行排序：

#默认数字从小到大排序 >>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36] #从大到小排序加reverse >>>sorted([36, 5, -12, 9, -21],reverse=True) #按绝对值从小到大排序 >>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 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'] #反向排序 >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']

练习 请用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) #按成绩从大到小排序 def by_score(t): return t[1] L1 = sorted(L, key=by_score,reverse=True) print(L1)

运行结果：

[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)] [('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

2.返回函数

返回函数可以把函数作为结果值返回。

普通求和函数定义：

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 lazy_sum.<locals>.sum at 0x101c6ed90>

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

>>> f() 25

2.1闭包

当一个函数返回了一个函数后，其内部的局部变量还被新函数引用，称作闭包。

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

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

返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量 i 已经变成了3，此时调用法f），得到的值均为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() print(f1(),f2(),f3()) #结果 1 4 9

练习 利用闭包返回一个计数器函数，每次调用它返回递增整数：

def createCounter(): i = 0 def counter(): nonlocal i #设置i为局部变量 i = i + 1 return i 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('测试失败!')

结果：

1 2 3 4 5 测试通过!

3.匿名函数——lambda

神秘的 lambda函数 终于出场了，匿名函数不需要显式地定义函数，好处就是：函数没有名字，不必担心函数名冲突。

在Python中，匿名函数的使用有助于简化代码。以map()函数为例，计算f(x)=x^2时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

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

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

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

练习 请用匿名函数改造下面的代码：

def is_odd(n): return n % 2 == 1 #原代码 #L = list(filter(is_odd, range(1, 20))) #改造后 L = list(filter(lambda x: x%2==1, range(1, 20))) print(L) #结果 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

4.装饰器——decorator

本质上，decorator就是一个返回函数的高阶函数。

我们要定义一个能打印日志的decorator，可以定义如下：

def log(func): #func是主要调用的函数 def wrapper(*args, **kw): #wrapper包装装饰器 print('call %s():' % func.__name__) #装饰器主要附加功能 return func(*args, **kw) #执行函数运算 return wrapper @log #借助Python的@语法，把decorator置于函数的定义处： def now(): print('2015-3-25')

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

>>> now() call now(): 2015-3-25

如果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 @log('execute') #三层嵌套装饰器用法，execute为自定义log文本 def now(): print('2015-3-25')

执行结果：

>>> now() execute now(): 2015-3-25

练习 请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：

import time, functools def metric(fn): start_time = time.time() #记录起始时间,time的用法 @functools.wraps(fn) #将原始函数（fn）的__name__复制到wraps def wrapper(*args, **kw): #定义装饰器（其中参数可为任意值：可变参数和任意参数） result = fn(*args, **kw) #将参数代入原始函数并赋值给result end_time = time.time() #此时已运行了原始函数（fn），可以记录结束时间了 print('%s() executed in %s ms' % (fn.__name__, end_time - start_time)) #这是装饰器的主体功能：“打印时间差” return result #这是装饰器的返回值，返回result（就是原始函数的结果） return wrapper #只是metric函数的返回，就是调用了装饰器函数 # 测试 @metric def fast(x, y): time.sleep(0.0012) return x + y; @metric def slow(x, y, z): time.sleep(0.1234) return x * y * z; f = fast(11, 22) s = slow(11, 22, 33) if f != 33: print('测试失败!') elif s != 7986: print('测试失败!')

结果：

fast() executed in 0.0012979507446289062 ms slow() executed in 0.12494874000549316 ms

decorator可以增强函数的功能，但定义起来有点复杂，有点难理解，需要继续学习了解。

5.偏函数——Partial function

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

用int()函数举例：

>>> int('12345') #int字符串转化为整数，默认十进制 12345 >>> 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) >> int2('1000000') 64 >>> int2('1010101') 85

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

>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85 >>> int2('1000000', base=10) #在调用int2时也可以传入其他值，如可改为十进制 1000000 创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入： int2 = functools.partial(int, base=2) #实际上固定了关键字参数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