Python笔记2（函数式编程）

4. 函数式编程

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务。这种分解可以称之为 面向过程的程序设计。

函数就是面向过程的程序设计的基本单元。

函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算。

我们首先要搞明白计算机（Computer）和计算（Compute）的概念。

在计算机的层次上，CPU执行的是加减乘除的指令代码，以及各种条件判断和跳转指令，所以，汇编语言是最贴近计算机的语言。

而计算则指数学意义上的计算，越是抽象的计算，离计算机硬件越远。

对应到编程语言，就是 越低级的语言，越贴近计算机，抽象程度低，执行效率高，比如C语言；越高级的语言，越贴近计算，抽象程度高，执行效率低，比如Lisp语言。

函数式编程是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为 没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。

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

Python对函数式编程提供部分支持。由于 Python允许使用变量，因此，Python不是纯函数式编程语言。

1. 高阶函数 Higher-order function

说明：

1. 变量可以指向函数

• demo：Python内置的求绝对值的函数abs()，调用该函数用以下代码：

>>> abs(-10)
10

但是，如果只写abs呢？

>>> abs
<built-in function abs>

可见，abs(-10)是函数调用，而abs是函数本身。

要获得函数调用结果，我们可以把结果赋值给变量：

>>> x = abs(-10)
>>> x
10

但是，如果把函数本身赋值给变量呢？

>>> f = abs
>>> f
<built-in function abs>

结论：函数本身也可以赋值给变量，即：变量可以指向函数。

如果一个变量指向了一个函数，那么，可否通过该变量来调用这个函数？用代码验证一下：

>>> f = abs
>>> f(-10)
10
# 或
>>> f = abs(-10)
>>> f
10

成功！说明变量f现在已经指向了abs函数本身。直接调用abs()函数和调用变量f()完全相同。

2. 函数名也是变量

函数名是指向函数的变量。对于abs()这个函数，完全可以把函数名abs看成变量，它指向一个可以计算绝对值的函数！

如果把abs指向其他对象，会有什么情况发生？

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

把abs指向10后，就无法通过abs(-10)调用该函数了！因为abs这个变量已经不指向求绝对值函数而是指向一个整数10！

当然实际代码绝对不能这么写，这里是为了说明函数名也是变量。要恢复abs函数，请重启Python交互环境。

注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用

import builtins
builtins.abs = 10

3. 传入函数

变量可以指向函数，函数的参数能接收变量。

高阶函数：一个函数就可以接收另一个函数作为参数。

一个最简单的高阶函数：

def add(x, y, f):
    return f(x) + f(y)

当我们调用add(-5, 6, abs)时，参数x，y和f分别接收-5，6和abs，根据函数定义，我们可以推导计算过程为：

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

小结：

• 编写高阶函数，就是让函数的参数能够接收别的函数。
• 把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

1. map/reduce

Python内建了map()和reduce()函数。

1. map()函数

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

• demo：有一个函数f(x)=x*x，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：

>>> def f(x):
	return x ** 2

>>> r = map(f, list(range(1, 10)))
>>> r
<map object at 0x7fbc0fa3b8b0>  # 可以看出r是一个高阶函数
# 输出方式一：list(r) 或 set(r) 或 tuple(r) 一次性输出
>>> list(r)  # 使用list()函数把结果以列表的形式打印出来
[0, 1, 4, 9, 16]
# 输出方式二：next(r) 一个个的输出
>>> next(r)
1
>>> next(r)
4
>>> next(r)
9
>>> next(r)
16
>>> next(r)
25
>>> next(r)
36
>>> next(r)
49
>>> next(r)
64
>>> next(r)
81
>>> next(r) # 输出最后一个再next会报错，因为没有元素了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个 Iterator，Iterator是惰性序列（使用next®可以一次一次把结果返回），因此通过list()函数让它把整个序列都计算出来并返回一个list。当然，使用 tuple 或 set 也是可以的：

>>> r = map(f, list(range(1, 10)))
>>> set(r)
{64, 1, 4, 36, 9, 16, 49, 81, 25}
>>> r = map(f, list(range(1, 10)))
>>> tuple(r)
(1, 4, 9, 16, 25, 36, 49, 64, 81)

当然使用for循环也是可以实现的：

>>> def f(x):
	return x ** 2

>>> l = []
>>> for i in range(1, 10):
	l.append(f(i))
	
>>> l
[1, 4, 9, 16, 25, 36, 49, 64, 81]

但这样看不出 把f(x)作用在list的每一个元素并把结果生成一个新的list。

• demo：把这个list所有数字转为字符串，一行代码即可。

>>> list(map(str, [1,2,3,4,5]))
['1','2','3','4','5']

2. reduce()函数

reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。

其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

• demo：对一个序列求和，就可以用reduce实现

>>> from functools import reduce
>>> def add(x, y):
	return x + y

>>> reduce(add, [1,3,5,7,9])
25

当然求和运算可以直接使用Python内建函数sum()，没必要用reduce()。但如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：

>>> from functools import reduce
>>> def func(x, y):
	return x * 10 + y
	# return x * 100 + y

>>> reduce(func, [1,3,5,7,9])
13579
# >>> reduce(func, [1,3,5,7,9])
# 103050709

这个例子本身没多大用处，但是，如果考虑到字符串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))

也就是说，假设Python没有提供int()函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！

2. filter 过滤序列

Python内建的 filter() 函数用于 过滤序列。

和map()类似，filter()也接受一个函数和一个序列。和map()不同的是，filter() 把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

>>> list(filter(lambda x: x % 2 == 1, list(range(10))))
[1, 3, 5, 7, 9]

把一个序列中的空字符串去掉：（这个序列只能是字符串组成）

>>> def f(x):
	return x and x.strip()

>>> list(filter(f, ['A', '', None, '  ', 'B']))
['A', 'B']

用filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

注意到filter()函数返回的是一个 Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。（也可用tuple或set转成元组或集合）

用filter使用埃氏筛法求素数

def _func1():
    # 返回3, 5, 7, 9...
    n = 1
    while True:
        n += 2
        yield n

def _func2(n):
    # 筛选函数，不整除
    return lambda x: x % n > 0
    
def func3():
    yield 2
    it = _func1()  # 初始序列
    while True:
        n = next(it)  # 返回序列的第一个数
        yield n
        it = filter(_func2(n), it)

# 打印100以内的素数
for n in func3():
    if n < 100:
        print(n)
    else:
        break
'''
输出：
2
3
5
7
11
。。。
89
97
'''

注意到Iterator是惰性计算的序列，所以我们可以用Python表示“全体自然数”，“全体素数”这样的序列，而代码非常简洁。

3. sorted 排序算法

无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。数字可以直接比较，但如果是字符串或者两个dict，比较的过程必须通过函数抽象出来。

1. sorted()函数对int排序：

• python内置的 sorted() 函数可对list中各元素进行排序：

>>> sorted([1,3,7,6,-4,8, -26])
[-26, -4, 1, 3, 6, 7, 8]

• sorted() 函数可以接收 key 函数进行自定义排序（例如根据绝对值大小排序）：

>>> sorted([1,3,7,6,-4,8, -26], key=abs)  # abs指绝对值
[1, 3, -4, 6, 7, 8, -26]

2. sorted()函数对str排序：

>>> sorted(['ai', 'Cerma','Aoli', 'zero', 'bob', 'Jason'])
['Aoli', 'Cerma', 'Jason', 'ai', 'bob', 'zero']

字母排序默认是根据ASCII码，因为 'Z' < 'a'， 所以 'a' 排在后边。
如果想忽略大小写排序，可以使用 key 将字符都转换成大写或小写

>>> sorted(['ai', 'Cerma','Aoli', 'zero', 'bob', 'Jason'], key=str.upper)
['ai', 'Aoli', 'bob', 'Cerma', 'Jason', 'zero']
>>> sorted(['ai', 'Cerma','Aoli', 'zero', 'bob', 'Jason'], key=str.lower)
['ai', 'Aoli', 'bob', 'Cerma', 'Jason', 'zero']

如果要反序排列，则在上边基础上添加 reverse=True 即可，默认False：

>>> sorted(['ai', 'Cerma','Aoli', 'zero', 'bob', 'Jason'], key=str.upper, reverse=True)
['zero', 'Jason', 'Cerma', 'bob', 'Aoli', 'ai']

小结： sorted()也是一个高阶函数。用sorted()排序的关键在于实现一个映射函数。

高阶函数小结

1. map

map(func, iterator) map(函数对象本身，迭代器)

Iterator迭代器是惰性序列，使用list()将整个序列输出

demo：将整数序列 [1,2,3,4,5,6,7,8,9] 转成字符串序列 ['1', '2', '3', '4', '5', '6', '7', '8', '9']

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

2. reduce

reduce(func, list) reduce(函数，序列)

• 函数必须接收两个参数，reduce把结果和序列的下一元素做计算

demo：把序列 [1,2,3,4,5] 变成整数 12345 ：

>>> from functools import reduce
>>> def func(x, y):
...     return x * 10 + y
...
>>> reduce(func, [1,2,3,4,5])
12345

3. filter 过滤序列，用于筛选

filter(func, list) filter(函数，序列)

filter() 接收一个函数和一个序列，把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

demo：一个序列，删掉奇数，只保留偶数

>>> list(filter(lambda x: x % 2 == 0, [1,2,3,4,5,6,7,8,9]))
[2, 4, 6, 8]

4. sorted 排序算法

sorted() 函数 关键在于实现一个映射函数。

语法1：sorted(list) sorted(序列)

语法2：sorted(list, key=约束条件)

demo1：单纯排序，正序或倒叙

>>> sorted([1,2,54,3])
[1, 2, 3, 54]
>>> sorted([1,2,54,3], reverse=True)
[54, 3, 2, 1]

demo2：有 key 条件的排序

>>> sorted([1,4,3,-65,51], key=abs)
[1, 3, 4, 51, -65]
>>> sorted(('Jason', 'bob', 'aliove', 'Aili'), key=str.lower)
['Aili', 'aliove', 'bob', 'Jason']

2. 返回函数

高阶函数可接收函数作为参数，也可把函数作为结果值返回。

demo：
（1）求和函数，将和返回

>>> def f1(*a):
...     s = 0
...     for i in a:
...             s += 1
...     return s

（2）如果不想直接返回 s 而是将该函数 f1 返回可以这样：

>>> def f2(*a):
...     def f1():
...             s = 0
...             for i in a:
...                     s += i
...             return s
...     return f1

（3）调用 f2 时返回的不是求和结果，而是求和函数：

>>> f = f2(1,2,4)
>>> f
<function f2.<locals>.f1 at 0x0000021915F0DEE8>

（4）调用 f 时才计算求和结果：

>>> f()
7

内部函数 f1 引用外部函数 f2 的参数和局部变量，当 f2 返回 f1 时，相关参数和变量都保存在返回的函数 f1 中，这种程序结构称为 “ 闭包 ”。

另外，调用 f2 时，每次调用都会返回一个新的函数，即使传入相同函数，也不等价：

>>> fa = f2(1,3,5,7,9)
>>> fb = f2(1,3,5,7,9)
>>> fa == fb
False

fa 和 fb 的调用互不影响。

闭包

返回的函数在其内部定义了引用局部变量 a ，所以当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。因此闭包用起来简单但实现起来不容易。

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

demo：

>>> def f1():
...     fs = []
...     for i in range(1, 4):  # 每次循环都创建一个新的函数
...             def f2():
...                     return i * i
...             fs.append(f2)
...     return fs	# 然后把创建的3个函数都返回
...
>>> fa, fb, fc = f1()
>>> fa()  # 执行 i * i 即 3 × 3
9
>>> fb()
9
>>> fc()
9

fa 、 fb 、 fc 都是9，而不是1、4、9，原因在于返回的函数引用了变量 i，但它并不是立即执行，等到 3 个函数都返回时他们所引用的变量 i 已经变成了 3，最终结果是 9。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

如果一定要引用循环变量的话，方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数的参数的值不变：

def f1():
    def f2(j):
        def f3():
            return j * j

        return f3

    fs = []
    for i in range(1, 4):
        fs.append(f2(i))
    return fs


fa, fb, fc = f1()
print(fa())  # 1
print(fb())  # 2
print(fc())  # 3

缺点是代码较长，可利用lambda函数缩短代码。

注意：

• 一个函数可以返回一个计算结果，也可以返回一个函数
• 返回一个函数时，切记该函数并未执行，返回函数中不要引用任何可能发生变化的变量。

3. 匿名函数

关键字 lambda 表示匿名函数，冒号前面的变量表示函数参数。

匿名函数有个限制，就是 只能有一个表达式，不用写 return，返回值就是该表达式的结果。

demo：求 x 的平方

lambda x: x ** 2
# 等价于
def func(x):
	return x ** 2

匿名函数的特点：

• 没有名字，不用担心函数名起冲突（好处）
• 匿名函数也是一个函数对象，可以把匿名函数赋值给一个变量，再利用变量来调用该函数

>>> l = lambda x : x ** 2
>>> l
<function <lambda> at 0x0000021915F10B88>
>>> l(4)
16

• 可以把匿名函数作为返回值返回

>>> def func(x, y):
...     return lambda x, y: x * y

小结：

Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。

4. 装饰器

装饰器（Decorator）：在代码运行期间动态增加功能

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

1. 普通装饰器（两层函数嵌套）

定义：

def log(func):
    def wrapper(*args, **kwargs):
        print('call %s():' % func.__name__)
        return func(*args, **kwargs)

    return wrapper

log 是一个 decorator，所以接受一个函数作为参数，并返回一个函数。使用Python的 @ 语法，把 decorator置于函数的定义处：

@log
def now():
    print('2021-02-19')

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

now()
# 输出：
call now():
2021-02-19

把 @log 放到 now() 函数的定义处相当于执行了语句：

now = log(now)

2. 带参数的装饰器（3层函数嵌套）

如果 decorator 本身需要传参，就需要写一个返回 decorator 的高阶函数。
比如要自定义log的文本：

def log(text):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log('啦啦啦')
def now():
    print('2021-02-19')

now()  # 调用 now()
# 结果如下：
啦啦啦 now():
2021-02-19

和两层嵌套的decorator相比，3层嵌套的效果是这样的：

now = log('execute')(now)

小结

一个完整的 decorator 是这样的：

不带参数的装饰器：

import functools


def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('call %s():' % func.__name__)
        return func(*args, **kwargs)

    return wrapper

带参数的装饰器：

import functools


def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kwargs)

        return wrapper

    return decorator

• 没有参数的装饰器，嵌套两层
• 有参数的装饰器，嵌套三层
• 都使用 functools.wrap(func) 由 import functools 而来

在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。

decorator可以增强函数的功能，定义起来虽然有点复杂，但使用起来非常灵活和方便。

5. 偏函数

偏函数(partial function)：Python的 functools 模块中的一个功能。偏函数可以通过设定参数的默认值，降低函数调用的难度。

demo：

• int() 函数可以把字符串转换成整数，当仅传入字符串时， int() 函数默认按十进制转换：

>>> int('12345')
12345

• 但 int() 函数还提供了额外的 base 参数，默认值为 10 。如果传入 base 参数，可以做 N进制 的转换：

>>> int('12345', base=8)
5349
>>> int('12345', base=8)
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')  # 也可以重新设置默认值 int2('1010101', base=10)
85

functools.partial 的作用：当函数的参数个数太多，需要简化时，使用偏函数把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

创建偏函数时，可接收 函数对象、*args、**kwargs 三个参数。