【Python】【整理】廖雪峰Python教程代码整理——5、函数式编程

5 函数式编程

5.1 高阶函数

变量指向函数：

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

一个函数接收另一个函数作为参数——高阶函数：

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

5.1.1 map/reduce

把函数f(x)=x²作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上：

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

所有数字转为字符串：

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

对一个序列求和：

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

把序列[1, 3, 5, 7, 9]变换成整数13579：

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

把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))

5.1.2 filter

在一个list中，删掉偶数，只保留奇数：

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

把一个序列中的空字符串删掉：

def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

用filter求素数：

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) # 构造新序列

5.1.3 sorted

对list进行排序：

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

按绝对值大小排序：

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

字符串排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']

忽略大小写排序：

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

5.2 返回函数

5.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时，才真正计算求和的结果：

>>> f()
25

5.2.2 闭包

引用循环变量：

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

5.3 匿名函数

计算f(x)=x²：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

把匿名函数作为返回值返回：

def build(x, y):
    return lambda: x * x + y * y

5.4 装饰器

函数对象被赋值给变量，通过变量调用该函数：

>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25

__name__属性拿到函数的名字：

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

定义一个能打印日志的decorator：

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

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

@log
def now():
    print('2015-3-25')

自定义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

@log('execute')
def now():
    print('2015-3-25')

3层嵌套的decorator用法：

@log('execute')
def now():
    print('2015-3-25')

>>> now()
execute now():
2015-3-25

一个完整的decorator的写法：

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

5.5 偏函数

int()函数把字符串转换为整数：

>>> int('12345')
12345

做N进制的转换：

>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

int2() 函数，默认把base=2传进去：

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

直接使用下面的代码创建一个新的函数int2：

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85