函数式编程

一、高阶函数

变量可以指向函数

>>> abs(-10)
10

求绝对值的函数

>>> abs
<built-in function abs>

只写函数名，说明abs指向了一个地址

>>> x = abs(-10)
>>> x
10

把结果赋值给变量

>>> f = abs 
>>> f
<built-in function abs>

试一试函数能否赋值

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

结论：变量可以指向函数

函数名也是变量

>>> abs = 10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable

结论：abs这个变量已经不指向求绝对值函数了，函数名也是变量

传入函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

一个最简单的高阶函数：

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

print(add(-5, 6, abs))

 虽然可以这么做，但是在实践当中，不会这么采用，以免造成冲突

map/reduce

map()函数的底层实现

def map_test(func,li):
    L = []
    for x in li:
        L.append(func(x))
    return L

def Add(data):
    return data + 1

rest = list(map_test(Add,[1,2,3]))
print(rest)

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

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

reduce()函数的第层实现

def reduce_test(func,li):
    total = 0
    # total = 1
    for i in li:
        total = func(total,i)
    return total

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

def Multi(x, y):
    return x * y

# rest = reduce_test(Add,[1,2,4,5])
# rest = reduce_test(Multi,[1,2,4,5])
rest = reduce_test(lambda x,y:x+y,[1,2,4,5])
print(rest)

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

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

比方说对一个序列求和，就可以用reduce实现：

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

str转换int

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

fitter

fitter函数用于过滤序列

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

例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

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

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

sorted

　　Python内置的sorted()函数就可以对list进行排序：

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

此外，sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个reversed_cmp函数：

def reversed_cmp(x, y):
    if x > y:
        return -1
    if x < y:
        return 1
    return 0

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

二、返回函数

 函数作为返回值

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function sum at 0x10452f668>

>>> f()
25

嵌套函数，返回嵌套函数名，最后调用时，用函数名().

闭包函数

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

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)    #没有立即执行
    return fs　　        #因为i为局部变量，执行到i=3时，由于没有取值，导致覆盖

f1, f2, f3 = count()

>>> f1()
9
>>> f2()
9
>>> f3()
9

如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变：

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

三、匿名函数

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

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

此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数

同样，也可以把匿名函数作为返回值返回

四、装饰器

 在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

装饰器的两个必须满足的要求：

1、不改变被修饰函数的调用方式（test()）

2、不改变被修饰函数的源代码

import time
def log(func):
    def wrapper(*args, **kw):   #为了解决不同函数传入的参数不同
        start_time = time.time()
        return func(*args, **kw)       #实际上是传给了func->now    return,接受返回值，
        stop_time = time.time()             #下面的内容无法实现
        print("执行了%.3fs"%(stop_time-start_time))
    return wrapper

@log    #now = log(now)
def now():
    time.sleep(3)
    print("程序执行完毕!")

now()