Python函数式编程

高阶函数

一个函数接收另一个函数做参数，这种函数称为高阶函数
函数式编程就是指这种高度抽象的编程范式。

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

map

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

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

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
    
i = reduce(add,[1,2,3,4,5])
print(i)

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]

m = map(char2num,'13579')
r = reduce(fn,m)
print(r)

看不懂

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

filter Python内建用于过滤序列

filter()也接收一个函数和一个序列。与map不同的是 filter()把传入的函数依次作用于每个函数。

filter()返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成

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

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

排序算法

>>> 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'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']

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

l = list(filter(is_odd,[1,2,3,4,5,6,7,8,9]))
print(l)

返回函数

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = n + ax
        return ax
    return sum
f = lazy_sum(1,2,3);
l = lazy_sum(1,2,3);
print()
#<function lazy_sum.<locals>.sum at 0x0000000002167510>
print(f())
# 6
print(f == l)
# False 每次都返回新的参数，调用结果互不影响

匿名函数

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

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

def build(x,y):
    return lambda: x*x + y*y
#b = build(5,5)
#print(b)

装饰器

函数对象 abs._name，可以拿到函数的名字

比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。

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

偏函数

• functools.partial就是帮助我们创建一个偏函数的
• functools.partial作用就是，把一个函数的某些参数给固定住（也就是设置默认值）

#可以通过base进行进制转换
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565

import functools
int2 = functools.partial(int,base=2)
#print(int2('1000000'))


int2 = functools.partial(int, base=2)
int2('10010')
kw = { 'base': 2 }
int('10010', **kw)


max2 = functools.partial(max, 10)
max2(5, 6, 7)
args = (10, 5, 6, 7)
max(*args)