函数式编程

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。
函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

高阶函数

变量可以指向函数

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

f = abs
print(f(-10))

10

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

函数名也是变量

函数名其实就是指向函数的变量！对于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！

传入函数

变量可以指向函数+函数的参数能接收变量=>一个函数可以接收另一个函数作为参数
这种函数就称之为高阶函数。

例子：

def add(x,y,f):
    return f(x) +f (y)
print(add(-5,5,abs))

10

map/reduce

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

`map()

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
比如一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下，或者将数字转换为字符串：

def f(x):
    return x*x
print(list(map(f,[1,2,3,4,5,6,7,8,9])))
print(list(map(str,[1,2,3,4,5,6,7,8,9])))

[1, 4, 9, 16, 25, 36, 49, 64, 81]
['1', '2', '3', '4', '5', '6', '7', '8', '9']

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
def fn(x,y):
    return x*10+y
print(reduce(add,[1,3,5,7]))
print(reduce(fn,[1,3,5,7]))

16
1357

混合

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]
print(map(char2num,'13579'))  #map()函数转换后的序列是惰性的，打印的是map作用后序列的地址。
print(reduce(fn,map(char2num,'13579')))

<map object at 0x0000002F024F3E10>
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))
print(str2int('13579'))

13579

用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))
print(str2int('13579'))

13579

练习

1.利用map()函数，将英文名字变为首字母大写，其他小写的规范名字

def normalize(name):
    name = name[0].upper() + name[1:].lower()
    return name
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

['Adam', 'Lisa', 'Bart']

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

# -*- coding: utf-8 -*-
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 * 5 * 7 * 9 = 945
测试成功!

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

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 str2float(s): 
    def str2num(t):#字符转换为数字
        return digits[t]
    def fn(x, y): #计算
        return 10*x +y
    L = list(map(str2num,s))
    n = L.index('.')#获取位置
    n1 = L[0:n]
    n2 = L[n+1:]
    return reduce(fn,n1) + reduce(fn,n2)/10**len(n2)  # **相当于^
print('str2float(\'123.456\') =', str2float('123.456'))
if abs(str2float('123.456') - 123.456) < 0.00001:
    print('测试成功!')
else:
    print('测试失败!')

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

对比：

print(456/10*3)
print(456/10**3)
print(456/(10**3))

136.8
0.456
0.456

filter

Python内建的filter()函数用于过滤序列（即筛选）。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
例如把一个序列中的空字符串删掉：

def not_empty(s):
    return s and s.strip() #
print(list(filter(not_empty,['A','','B',None,'C',''])))

['A', 'B', 'C']

补充：

not_empty只是拿来判断list中每个元素是否为真，并不更改list里的值
strip()参数为空时表示，删除空白符（包括’\n’, ‘\r’, ‘\t’, ’ ')
s is None，那么s会被判断为False；s is not None，那么s会被判断为True，and以后返回后一项，返回了s.strip()。
s.strip() 不能单独使用

filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。（只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。）
用filter求素数
方法：
（1）首先，列出从2开始的所有自然数，构造一个序列
（2）取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉
（3）取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉
（4）不断筛下去，就可以得到所有的素数
代码实现：

def _odd_iter():            #先构造一个从3开始的奇数序列
    n = 1
    while True:
        n = n + 2 
        yield n            #这是一个生成器，并且是一个无限序列。
        
def _not_divisible(n):     #定义一个筛选函数
    return lambda x:x % n > 0
    
#生成器先返回第一个素数2，然后，利用filter()不断产生筛选后的新的序列    
def primes():              #定义一个生成器，不断返回下一个素数
    yield 2
    it = _odd_iter()       # 初始序列
    while True:
        n = next(it)       # 返回序列的第一个数
        yield n
        it =filter (_not_divisible(n),it)   # 构造新序列
        
#primes()也是一个无限序列，所以调用时需要设置一个退出循环的条件
for n in primes():         # 打印50以内的素数
    if n < 50:
        print(n)
    else:
        break

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47

练习

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

def is_palindrome(n):
    return str(n) == str(n)[::-1]
output = filter(is_palindrome, range(1, 200))
print('1~100:', 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~100: [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]
测试成功!

sorted

Python内置的sorted()函数可以对list进行排序，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，用sorted()排序的关键在于实现一个映射函数。例如：

print(sorted([3,-5,9,-2]))
print(sorted([3,-5,9,-2],key = abs))  #按绝对值排序

[-5, -2, 3, 9]
[-2, 3, -5, 9]

key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。对比原始的list和经过key=abs处理过的list：

list = [3,-5,9,-2]
key = [3,5,9,2]

然后sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素。
对字符串进行排序，按照ASCII的大小比较，由于’Z’ < ‘a’，大写字母Z会排在小写字母a的前面。

print(sorted(['bob','about','Zoo']))

['Zoo', 'about', 'bob']

对字符串进行忽略大小写的排序：

print(sorted(['bob','about','Zoo'],key = str.lower))

['about', 'bob', 'Zoo']

要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：

print(sorted(['bob','about','Zoo'],key = str.lower,reverse=True))

['Zoo', 'bob', 'about']

练习

1.用sorted()对表示学生名字和成绩的列表分别按名字排序：

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
def by_name(t):
    return t[0].lower()  #或者return t
L2 = sorted(L, key=by_name)
print(L2)

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

2.按成绩从高到低排序：

# -*- coding: utf-8 -*-
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)]

返回函数

函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。
实现可变参数求和(功能:不需要立刻求和，而是在后面的代码中，根据需要再计算,可以不返回求和的结果，而是返回求和的函数):

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum    #注意是sum而不是sum()
f = lazy_sum(1,3,5,7,9)     #调用lazy_sum()时，返回的并不是求和结果，而是求和函数
print(f)
print(f())

<function lazy_sum.<locals>.sum at 0x00000147183038C8>
25

函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2   #f1()和f2()的调用结果互不影响
False

注意：
调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数

闭包

闭包理解：https://www.cnblogs.com/s-1314-521/p/9763376.html
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

def count():
    fs = []
    for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
    return fs
f1,f2,f3 = count()
print(f1(),f2(),f3())

9 9 9     #不是1 4 9

注意：
返回的函数并没有立刻执行，而是直到调用了f()才执行
上面的例子中，每次循环，都创建了一个新的函数，然后，把创建的3个函数都返回了
返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。
返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

要想用到循环变量，再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变（缺点：代码较长，可利用lambda函数缩短代码）：

def count():
    def f(j):
        def g():
            return j * j
        return g
    fs = []
    for i in range(1,4):
        fs.append(f(i))
    return fs
f1,f2,f3 = count()
print(f1(),f2(),f3())

1 4 9

练习

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

def createCounter():
    cnt = [0]    #cnt=[0]是创建一个list，cnt[0]指的是这个list第一个元素
    #print(cnt[0])
    def counter():
        cnt[0] = cnt[0] + 1
        return cnt[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('测试失败!')

1 2 3 4 5
测试通过!

匿名函数

在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
例如传入匿名函数：

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

关键字lambda表示匿名函数，冒号前面的x表示函数参数。
限制：只能有一个表达式，不用写return，返回值就是该表达式的结果。
匿名函数不用担心函数名冲突，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

f = lambda x:x * x
print(f(5))
print(f)

25
<function <lambda> at 0x0000019E11C12EA0>

匿名函数也可以作为返回值返回

def build(x,y):
    return lambda:x * x + y * y
f = build(1,2)
print(f())

5

装饰器

装饰器：在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数：

def now():
    print('2020-09-08')
f = now
print(f())

2020-09-08
None

函数对象有一个__name__属性，可以拿到函数的名字：

>>> now.__name__
'now'
>>> f.__name__
'now'

decorator是一个返回函数的高阶函数，定义一个能打印日志的decorator，如下：

def log(func):
    def wrapper(*args,**kw):
        print('call %s():'%func.__name__)
        return func(*args,**kw)
    return wrapper
@log
def now():
    print('2020-09-08')
print(now())

call now():
2020-09-08
None

其中把@log放到now()函数的定义处，等价于：now = log(now)
由于log()是一个decorator，返回一个函数，所以，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数，于是调用now()将执行新函数，即在log()函数中返回的wrapper()函数。
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
如果decorator本身需要传入参数，就需要编写一个返回decorator的高阶函数，比如，要自定义log的文本：

#3层嵌套的decorator
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')
def now():
    print('2020-09-08')
now()              #区分两种的输出
print(now())
print(now.__name__)

execute now():
2020-09-08
execute now():
2020-09-08
None
wrapper

3层嵌套等价于now = log('execute')(now)
分析：
首先执行log('execute')，返回的是decorator函数。
然后调用返回的函数，参数是now函数，返回值最终是wrapper函数。
最后因为函数也是对象，它有__name__等属性，但经过decorator装饰之后的函数，它们的__name__已经从原来的'now'变成了'wrapper'。
因为返回的那个wrapper()函数名字就是'wrapper'，所以，需要把原始函数的__name__等属性复制到wrapper()函数中，否则，有些依赖函数签名的代码执行就会出错。
不需要编写wrapper.__name__ = func.__name__，Python内置的functools.wraps可以完成，完整代码：

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

带参数的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
@log('execute')    #没有下面的now()这句话也不执行
def now():
    print('2020-09-08')
now()

execute now():
2020-09-08

练习

请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：
（参考别人的答案，还没搞懂）

# # -*- coding: utf-8 -*-
import time, functools
def metric(fn):
    @functools.wraps(fn)
    def wrapper(*args):
        t1 = time.time()
        result = fn(*args)
        t2 = time.time()
        print('%s executed in %s ms' % (fn.__name__, t2 - t1))
        return result
    return wrapper
# 测试
@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.0020406246185302734 ms
slow executed in 0.12458181381225586 ms

思考（这一块不是很懂，回顾的时候再来补充）：
写出一个@log的decorator，使它既支持：

@log
def f():
    pass

又支持

@log('execute')
def f():
    pass

偏函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。
作用：把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。
例如：

#int()函数默认按十进制转换
print(int('12345'))

#可以传入base参数，做N进制的转换
print(int('12345',base = 8))
print(int('12345',base = 16))

12345
5349
74565

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，这时可以定义一个int2()的函数，默认把base=2传进去：

def int2(x,base = 2):
    return int(x,base)
print(int2('1000000'))

64

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

import functools
int2 = functools.partial(int,base = 2)      #默认值为2
print(int2('1000000'))
print(int2('1000000',base = 10))     #可以在函数调用时传入其他值

64
1000000

最后，创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数，当传入：

int2 = functools.partial(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

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