Python3 Python 函数式编程

Posted 2021-04-12 猿来如痴

本系列主要学习Python的基本使用和语法知识，后续可能会围绕着AI学习展开。
Python3 (1) Python语言的简介
Python3 (2) Python语法基础
Python3 (3) Python函数
Python3 (4) Python高级特性
Python3 (5) Python 函数式编程
Python支持函数式编程，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

高阶函数

对于一直在java中学习的人来说，高阶函数还是一个陌生、高大上的名词，它有三个特点：

• 变量可以指向函数

• 函数名也是变量

• 函数可以作为参数传入

所以高阶函数的定义：把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def add(x, y, f):
    return f(x) + f(y)
print('|x|+|y| = ',add(-5, 6, abs))

输出结果：

|x|+|y| =  11

几个内置高阶函数

map/reduce

首先声明map函数与java中的map是两个名词，没有关联。map高阶函数的定义：map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
L = list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L)

输出结果：

['1', '2', '3', '4', '5', '6', '7', '8', '9']

将list中的元素转换成字符串。

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

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from functools import reduce
def fn(x,y):
    return x*10+y
L = reduce(fn, [1,2,3,4,5])
print(L)

输出结果：

12345

用list 实现一个按list序列生成一个整数，它的结果就是一个最终的数。

使用map 和 reduce 写一个字符串转整数的函数、字符串转浮点数的函数：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
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):
    def fn(x, y):
        return x * 10 + y
    return reduce(fn, map(char2num, s))
def str2float(s):
    n = s.index('.')
    return reduce(lambda x,y:x*10+y,map(char2num,s[:n]+s[n+1:]))/10**n
print(str2int('10001'))
print(str2float('10001.0001'))

输出结果：

10001
1000.10001

filter

用于过滤序列，filter 与map定义的格式相同，参数接受一个函数，一个序列，返回一个Iterator。filter通过判断函数的返回值是否为True来丢弃一些元素。

filter的主要应用是实现一个筛选函数：我们来实现一个素数的序列

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
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
    it = _odd_iter() # 初始序列
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) # 构造新序列
# 打印1000以内的素数:
for n in primes():
    if n < 20:
        print(n)
    else:
        break

输出结果：

2
3
5
7
11
13
17
19

实现原理，依次将3，5，7，9… 的倍数筛选完，最终剩下的为素数。
练习一个回数的筛选：从左向右读和从右向左读都是一样的数

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def is_palindrome(n):
   return str(n) == str(n)[::-1]
# 测试:
output = filter(is_palindrome, range(1, 200))
print('1~200:', list(output))

输出结果：

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]

sorted

sorted 排序高阶函数，它的使用非常灵活，可以传入自定义的排序函数、反向排序，在复杂的排序中核心代码还是非常的简洁。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
L = [3,1,-5,-2,9]
#普通的用法
print(sorted(L))
#反向排序
print(sorted(L,reverse=True))
K = ['Apple','banana','Pear','tomato']
print(sorted(K))
#忽略大小写
print(sorted(K,key=str.lower))
#反向排序
print(sorted(K,key=str.lower,reverse=True))

输出结果：

[-5, -2, 1, 3, 9]
[9, 3, 1, -2, -5]
['Apple', 'Pear', 'banana', 'tomato']
['Apple', 'banana', 'Pear', 'tomato']
['tomato', 'Pear', 'banana', 'Apple']

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回，我们来聊一聊返回函数的问题。
当我们调用一个函数时，不需要立即得到结果，想在需要的时候再进行计算，那么我们就可以返回一个函数而不是直接一个结果。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def laz_count(*args):
    def count():
        ax = 0
        for n in args:
            ax = ax + n*n
        return ax
    return count
f1 = laz_count(1, 2, 3, 4, 5,6)
f2 = laz_count(1, 2, 3, 4, 5,6)
print(f1())
print(f1==f2)

输出结果：

91
False

从上面可以看出，函数返回值也是一个函数，需要再次调用才能得出结果，并且每次返回的都是一个新的函数。

闭包

闭包的定义与java中的内部类有些相似，闭包指的是函数再定义函数的情况，即：内部函数可以外部函数的参数和局部变量，当外部函数返回内部函数时，相关的参数和变量都保存在返回的函数中。这种行为称之为 “闭包”。

# -*- coding: utf-8 -*-
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())
def count():
    fs = []
    for i in range(1, 4):
        def f(i):
            def g():
                return i * i
            return g
        # f(i)立刻被执行，因此i的当前值被传入f()
        fs.append(f(i))
    return fs
f1, f2, f3 = count()

输出结果：

9 9 9
1 4 9

由于返回的函数不是立即执行，在调用执行时，i变量已经成为3，如果要输出想要的值，需要再创建一个函数将变量i 与函数绑定。

匿名函数

匿名函数其实就是lambda 表达式的使用，lambda表达式的使用场景就是匿名函数，与java 的匿名类很相似。

• 关键字lambda表示匿名函数，冒号前面的x表示函数参数

• 匿名函数有个限制，就是只能有一个表达式，表达式的值就是返回值，不需要return

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

# -*- coding: utf-8 -*-
L = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L)
def f(x,y):
    return lambda :x*x+y*y
x = f(2,3)
print(x())

输出结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81]
13

装饰器

可以在这代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。decorator就是一个返回函数的高阶函数。装饰器在java中成为装饰者模式，需要通过继承，组合来实现，python中在函数层面就可以实现。这就是python 的强大之处

下面我们来通过示例学习，decorator的用法：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
@log
def now(x,y):
    print('2018-1-1',x,y)
now(5,6)
print(now.__name__)
def now(x,y):
    print('2018-1-1',x,y)
f =log(now)
f(1,2)
print(now.__name__)

输出结果：

call now():
2018-1-1 5 6
wrapper
call now():
2018-1-1 1 2
now

第一 我们定义了一个在函数调用开始前输出函数名的decorator
第二 在使用装饰器时可以通过@decorator的方式注解也可以通过传入函数的方式
第三 在使用@decorator的方式装饰器后，函数的__name__变成了  wrapper 这样显然是不合理的，我们目的是为了扩展函数的功能，不是改变函数的签名，所以python 中 内置了functools.wraps来还原函数的签名，具体如下：

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('123')
def now(x,y):
    print('2018-1-1',x,y)
now(5,6)
print(now.__name__)
def now(x,y):
    print('2018-1-1',x,y)
f =log('456')(now)
f(1,2)
print(now.__name__)

输出结果：

123 now():
2018-1-1 5 6
now
456 now():
2018-1-1 1 2
now

这个示例中我们验证了@functools.wraps(func)的用法，并且多层嵌套自定义log输出的字段。
下面做一个函数执行时间的练习：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import functools
import time
def metric(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kw):
        start = time.time()
        result = fn(*args, **kw)
        end = time.time()
        print('%s 执行时间 %.2fs ms' % (fn.__name__, (end - start) * 1000))
        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 执行时间 2.00s ms
slow 执行时间 124.60s ms

偏函数

通过传入函数，和对应的规则，生成一个新的函数，方便调用 的方式成为偏函数partial。

偏函数的使用：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import functools
def int2(x, base=2):
    return int(x, base)
print(int2('1111'))
int2 = functools.partial(int, base=2)
print(int2('1111'))

输出结果：

15
15

创建偏函数时，实际上可以接收函数对象、args和*kw这3个参数,偏函数是 functools 模块中提供的一种固定某些参数来简化一些函数的调用难度的作用。

参考

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317848428125ae6aa24068b4c50a7e71501ab275d52000