Python 学习笔记4 - 函数式编程 Functional

函数式编程虽然也可以归结到面向过程的程序设计，但其思想更接近数学计算

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

高阶函数 Higher-order function

一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

一个最简单的高阶函数：

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

map/reduce

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

• map() 函数接收两个参数，一个是函数，一个是 Iterable ，map 将传入的函数依次作用到序列的每个元素，并把结果作为新的 Iterator 返回

def f(x):
    return x * x

r = map(f, list(range(0,10)))

# 结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list
list(r)

for n in r:
    print(n)

# 把这个list所有数字转为字符串
# 函数 str() 依次作用到序列的每个元素
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) ==> ['1', '2', '3', '4', '5', '6', '7', '8', '9']

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

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

from functools import reduce

def g(x, y):
    return x + y

reduce(g, list(range(0,10))) ==> 45

# 把list 转换为整数
from functools import reduce

def fn(x, y):
    return x * 10 + y

reduce(fn, [1, 3, 5, 7, 9])

# 把str转换为int
from functools import reduce

def fn(x, y):
    return x * 10 + y
    
def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    
reduce(fn, map(char2num, '13579'))



# 整理成一个str2int的函数就是：
from functools import reduce

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(fn, map(char2num, s))
    


# 用lambda函数进一步简化成：
from functools import reduce

def char2num(s):
    return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]

def str2int(s):
    return reduce(lambda x, y: x * 10 + y, map(char2num, s))

def normalize(name):
    a = ''
    for i, value in enumerate(name):
        if i == 0:
            a += value.upper()
        else:
            a += value.lower()
    return a
    

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)

from functools import reduce

def prod(L):
    def fn(x, y):
        return x * y
    return reduce(fn, L)

print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))

def str2float(s):
    def fn(x, y):
        return x * 10 + y
    def fx(x, y):
        return x / 10 + y
    def char2num(s):
        return {'0':0, '1':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9}[s]
    L = s.split('.', 1)
    print(L)
    return reduce(fn, map(char2num, L[0])) + reduce(fx, map(char2num, L[1][-1::-1]))/10

print('str2float(\'123.456\')=', str2float('123.456'))

filter

filter()函数用于过滤序列

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

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']

# 求素数

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(lambda x: x % n > 0, it)
        it = filter(_not_divisible(n), it) # 构造新序列
        
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

sorted

sorted([36, 5, -12, 9, -21]) ==> [-21, -12, 5, 9, 36]

sorted() 函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序。key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

sorted([36, 5, -12, 9, -21], key=abs) => [5, 9, -12, -21, 36]

对字符串排序，是按照ASCII的大小比较的

# 忽略大小写来比较两个字符串
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']

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

def by_name(t):
    return t[0].lower()

def by_score(t):
    return t[1]

L1 = sorted(L, key=by_name)
print(L1)
L2 = sorted(L, key=by_score)
print(L2)

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回

def lazy_sum(*args):
    # 内部函数sum可以引用外部函数lazy_sum的参数和局部变量
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    # 当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”
    return sum

f = lazy_sum(1, 3, 5, 7, 9)
f() ==> 25

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

f1, f2, f3 = count()
f1() ==> 9
f2() ==> 9
f3() ==> 9

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

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        # f(i)立刻被执行，因此i的当前值被传入f()
        fs.append(f(i)) 
    return fs

匿名函数

匿名函数类似如下：

lambda x: x * x

关键字lambda表示匿名函数，冒号前面的x表示函数参数
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果

装饰器 Decorator

假设我们要增强函数的功能，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）

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

# 接受一个函数作为参数，并返回一个函数
def log(func):
    # wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

借助Python的@语法，把decorator置于函数的定义处：

# 把@log放到now()函数的定义处，相当于执行了语句：now = log(now)
@log
def now():
    print('2015-3-25')
    
now()

如果decorator本身需要传入参数，那就需要编写一个返回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

这个3层嵌套的decorator用法如下：

# 和两层嵌套的decorator相比，3层嵌套的效果是这样的：now = log('execute')(now)
# 区别：log 是函数名，log('execute') 是函数执行后的返回结果
@log('execute')
def now():
    print('2015-3-25')

now()

按以上两种 decorator 装饰之后的函数，它们的 __name__ 已经从原来的'now'变成了'wrapper'：

now.__name__ ==> 'wrapper'

Python内置的 functools.wraps 原始函数的 __name__ 等属性复制到 decorator 替换的函数中，则前面两个 decorator 的完整写法为：

import functools


def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
    
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

import functools

# 支持带和不带参数的 decorator 
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*arg,**kw):
            # 能在函数调用的前后打印出的日志
            try:
                print('begin call')
                if isinstance(text, str):
                    print('param :', text)
                return func(*arg,**kw)
            finally:
                print('end call')
        return wrapper
    
    if hasattr(text,'__call__'):
        return decorator(text)
    else:
        return decorator
    
    

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

@log('with param')
def g():
    print('execute g()')
    

f()
g()

偏函数 Partial function

Python 的 functools 模块提供了很多有用的功能，其中一个就是偏函数

Python 的偏函数和数学意义上的偏函数不一样

functools.partial 的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数

import functools

int2 = functools.partial(int, base=2)

int2('1000000') ==> 64

# 这里仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值
int2('1000000', base=10) ==> 1000000

# 创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
int2 = functools.partial(int, base=2)

# 相当于
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