Pyhton学习笔记五：函数式编程

• 函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

---

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返回；
• 我们有一个函数 $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])
>>> 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()求素数

• 计算素数的一个方法是埃氏筛法，算法说明如下：
  1. 列出从2开始的所有自然数，构成一个序列：
     2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, …
  2. 取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：
     3, 5, 7, 9, 11, 13, 15, 17, 19, …
  3. 取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：
     5, 7, 11, 13, 17, 19, …
  4. 取新序列的第一个数5，然后用5把序列的5的倍数筛掉：
     7, 11, 13, 17, 19, …
  5. 不断筛选下去，就可以得到所有的素数，下面用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