整理Python（函数式编程）

高阶函数：能接收函数做参数的函数

import math
def add(x,y,f):
    return f(x)+f(y)
print(add(25,9,math.sqrt)

1.map()函数：接收一个函数f和一个list，并通过把函数f一次作用在list的每个元素上，返回一个新的list

def formate_name(s):
    return s.capitalize()   #capitalize()返回每个单词的首字母大写
print(map(formate_name,['allen','mark','bar']))

2.reduce()函数：接收一个函数f和一个list，注意，reduce函数需要接收两个参数，即list中的参数，前两个调用函数f，生成一个新值，再加上list中的第三个，两两调用函数f，返回最终结果值

#输出2,4,5,7,13的乘积
def prod(x,y):
    return x*y
print(reduce(prod,[2,4,5,7,13]))

3.filter()函数：接收一个函数f和一个list，函数f的作用是对每个元素进行判断，返回T or F ,filter（）根据判断结果过滤掉不符合条件的元素，返回一个符合条件的list

#返回一个1-100的平方根是整数的list
import math
def is_sqr(x):
    return math.sqrt(x)==int(math.sqrt(x))

print(filter(is_sqr,range(1,101)))

4.排序函数sorted()：x<y,返回-1，x=y返回0，x>y,返回1，即由小到大

                       如果要由大到小，后面需要传入 reversed_cmp, 即 sorted(L,reversed_cmp)

给sorted传入key函数，即可实现忽略大小写

 sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)

5.返回函数：不是很理解，好像是数学中，f和f（x）的区别，f是一个函数，f（x）是一个函数值

#编写一个函数calc_prod(lst),它可以接收一个list，返回一个函数，返回函数可以计算参数的乘积
def calc_prod(lst):
    def calc():
        def prod(x,y):
            return x*y
        return reduce(prod,lst)
    return calc

f=calc_prod([1,2,3,4])
print(f)
print(f())

6.闭包：内层函数引用了外层函数的变量，返回内层函数，一定要确定内层函数引用的外部变量，在函数返回后不能变。返回函数不要引用任何循环变量，或后续发生变化的变量

def f(j):
    def g():  #g所引用的变量j不是循环变量
        return j*j
    return g

# 返回闭包不能引用循环变量，写下count()函数，返回能计算1*1,2*2,3*3的函数
def count():
    fs=[]
    for i in range(1,4):
        def f(j):
            def g():
                return j*j
            return g
        r=f(i)
        fs.append(r)
    return fs
f1,f2,f3=count()
print(f1(),f2(),f3())    返回 1  4  9

7.匿名函数lambda():有时不需要显示的定义函数，直接出入匿名函数即可 

map(lambda x:x*x,[1,2,3,4,5,6,7])

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

匿名函数有个限制，就试试只能有一个表达式，不写return

#降序
sorted([0,5,1,9,6,15],lambda x,y:-cmp(x,y))

#绝对值
myabs=lambda x:-x if x<0 else x

print(list(filter(lambda s:s and len(s.strip())>0,['test','none','','str '])))
#lambda s:s and len(s.strip())>0，表示函数接受一个参数s，and前面的s表示：要求s本身不是一个空字符串，因为空字符串看做False，后面的len(s.strip())>0表示s这个字符串在头尾去空格后的长度大于0，即不是空字符串且长度大于0，返回True

Python3中filter，前面要加list（）

8.装饰器decorator 

def log(f):                                        #定义装饰器高阶函数，以要装饰的函数作为参数
    def fn(x):                                     #内部相当于重构 要装饰的函数f， 重命名为fn
        print('call'+f.__name__+'()...')           # 加特技 print（）
        return f(x)                                #为了不重写原来的函数的代码，所以用return f(x)代替原来的代码
    return fn                                      #将被装饰的fn返回

作用：简化代码，避免每个函数编写重复性代码  

打印日志：@log   检测性能：@performance  数据库事务：@transaction  URL路由：@post('/register')

# 编写一个@performance ，可以打印出函数调用的时间
#计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差
import time 
def performance(f):
    def fn(*args,**kw):
        t1=time.time()
        r=f(*args,**kw)
        t2=time.time()
        print('call %s() in %fs' %(f.__name__,(t2-t1)))       # %s:字符串（采用str（）的显示） 
        return r                                              # %r:字符串（采用repr（）的显示）
    return fn                                                 # %c：单个字符
                                                              # %b：二进制整数
@performance                                                  # %d：十进制整数
def factorial(n):                          
    return reduce(lambda x,y:x*y,range(1,n+1))          
print(factorial(10))

对比上面的代码，@perfomance 只能打印秒，现在添加‘ms’

import time 
def performance(unit):
    def perf_decorate(f):
        def wrapper(*args,**kw):
            t1=time.time
            r=f(*args,**kw)
            t2=time,time
            t=(t2-t1)*1000 if unit='ms' else(t2-t1)
            print('call %s() in %f %s'%(f.__name__,t,unit))
            return r
        return wrapper
    return perf_decorator

@performance('ms')

def factorial(n):                          
    return reduce(lambda x,y:x*y,range(1,n+1))          
print(factorial(10))   

@functools ：可以自动化复制原函数所有必要的属性到新函数上

import time 
def performance(unit):
    def perf_decorate(f):
        @functools.wraps(f)
        def wrapper(*args,**kw):
            t1=time.time
            r=f(*args,**kw)
            t2=time,time
            t=(t2-t1)*1000 if unit='ms' else(t2-t1)
            print('call %s() in %f %s'%(f.__name__,t,unit))
            return r
        return wrapper
    return perf_decorator

9. 偏函数 

functools.partial( ) : 可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值

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

#利用functools.partial() 实现忽略大小写的排序
import functools
sorted_ignore_case=functools.partial(sorted,reverse=False,key=lambda key:key and key[0].upper())

sorted_ignore_case=functools.partial(sorted,reverse=False,key=lambda key:key.upper())

#标记的两行不知道哪个可以  ，还是都不可以啊

print(sorted_ignore_case(['','bob','wanfg','wu','yi','fan']))