Python函数式编程

1. 函数式编程

就是把函数作为参数传入另一个函数

2. map函数

需要两个参数，一个是函数，另外一个是迭代器，并将结果作为新的迭代器

把函数作用在迭代器上的每一个元素(其实这就默认有个for循环)，函数接收的参数就是迭代器的元素

2.1 reduce

把结果继续和序列的下一个元素做合并计算(相当于把上一次的结果赋值给本次，然后本次再和下一次运算)。

a = ['adam', 'LISA', 'barT']
def f(i):
    return i.capitalize()
b = list(map(f, ['adam', 'LISA', 'barT']))#首字母大写
print(b)

from functools import reduce
def m(x,y):
    return x*y
c = reduce(m,[3, 5, 7, 9])
print(c)

首先判断每个字符是不是点，如果不是，返回整形。

其实判断返回的字符是不是点，如果不是，返回计算公式。如果是，返回x，即上次运行的结果。

from functools import reduce


def c_f(x, y):
    if y != '.':
        return 10 * x + y
    else:
        return x


def is_point(cc):
    if cc != '.':
        return int(cc)
    else:
        return '.'


def _final(str):
    b = reduce(c_f, map(is_point, str))
    pLen = len(str) - str.find('.') - 1
    b = b / (10 ** pLen)
    print(b)


_final('12.345')

3. filter

把传入的函数作用每个值，返回Ture or False

from functools import reduce

def c_f(n):
    return str(n) == str(n)[::-1]

c = list(filter(c_f,list(range(1,100))))
print(c)

4. sorted

排序，可以使用key=abs，指定排序，也可以把key指定为函数，接受每个元素作为输入变量

def d(v):
    return v[1]

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
b = sorted(L,key=d)
print(b)

5. 返回函数

称为闭包

返回闭包中禁止使用循环变量，或者后续发生变化的变量。但可以在新建函数调用返回函数

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:#不能这么用
            ax = ax + n
        return ax
    return sum

 

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

在闭包中，内部函数无权限改变外部函数的指向，需要用nonlocal var。或者使用列表

def c():
    l = [0]
    def cc():
        # nolocal a
        l[0] = l[0] + 1
        return l[0]
    return cc

6. 匿名函数

lambda x : x * x

就是说传入x, 返回 x * x，只能有一个返回语句。

可以返回labmda函数，也可以把lambda函数传给一个变量

7. 装饰器

不改变已封装的代码，增加新功能。

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

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)#这一步是调用函数
    return wrapper #这一行只是返回函数,并没有调用函数

d = log(now) #注意此时还应该使用now，而不是d。此处只是为了举例
d()

now是封装好的代码，log是新建代码，意在给now函数增加新功能

log(now): 首先d指向 log函数空间，执行log函数。

　　　　返回wraraper(是返回不是调用)， 此时d指向wrapper空间

　　　　调用d时，指向wrapper空间，执行wrapper。同时返回的是函数执行，而不是函数。

8. 偏函数

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

把python已有的函数，修改参数后，成为一个新函数