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