高阶函数

1.map()函数
接收两个参数，一个是函数，一个是可迭代变量，将传入的的函数依次作用到序列的每个元素，并把结果作为新的可迭代变量返回.
源代码:

#!/usr/bin/python3
def map(f,iterable):
	for i in iterable:
		yield i

map（）传入的第一个参数是f，即函数对象本身。由于结果是一个Iterator，Iterator是惰性序列，因此通过list（）函数让它把整个序列都计算出来并返回一个list.
举例：用map()函数求[1,2,3,4,5,6]的平方.

#!/usr/bin/python3
def f(x):
	return x**2
r=map(f,[1,2,3,4,5,6])
lst=[]
for n in r:
	lst.append(n)
print(lst)
输出结果:lst=[1,4,9,16,25,36]

2.reduce()函数
reduce把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计.
源代码:

	def freduce(f,inter):
    lst = []
    for i in range(len(inter)-1):
        if i==0:
            lst.append(f(inter[i],inter[i+1]))  
        else:
            lst.append(f(lst[i-1],inter[i+1])) ###进行累加，将之前的累加和加上当前值
    return lst     ####将每次的结过存在列表中输出
e = freduce(lambda x,y:x+y,[1,3,5,7,9]) ####使用匿名函数
print(e)

使用前需要调用reduce函数：from functools import reduce.
举例：用reduce()函数将序列[1,3,5,7,9,]转变成整数13579

#!/usr/bin/python3
from functools import reduce
def f(x,y):
	return x*10+y
a=reduce(f,[1,3,5,7,9])
print(a)
输出结果:a=13579

3.filter()函数
和map()函数相似，filter()函数也接收一个参数和一个序列。和map()函数不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是false决定保留还是丢弃元素.
关键在于正确实现一个筛选函数.
filter()函数返回的是一个Iterator,也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list.
源代码:

def filter(f,iter):
for i in iter:
    if f(i):
        yield i
c = filter(lambda x:x%2==0,[1,2,3,4,5,6])
for i in c:
    print(i)

举例：使用filter()函数将序列[1,2,3,4,5,6]中的偶数筛选出来

#!/usr/bin/python3
def is_odd(n):
	return n%2==0
a=list(filter(is_odd,[1,2,3,4,5,6]))
print(a)
输出结果：a=[2,4,6]

4.sorted() 排序算法
Python内置的sorted()函数就可以对list进行排序；
还可以接收一个key函数来实现自定义的排序.
源代码:

def fsorted(f,inter):
    lst=[]
    for i in inter:
        lst.append(i)
    for i in range(1,len(lst)):
        b=lst[i]						
        a = f((lst[i]))                                      
        j = i
        while a<f(lst[j-1]):               
            lst[j]=lst[j-1]
            j-=1
            if j<1:
                break
        lst[j]=b                                          

   print(lst)
f = fsorted(lambda x:abs(x),[1,6,-5,4,3,2,9])

默认情况下，字符串大小是按照ASCII的大小比较z<a，一般忽略大小，用lower全部改为小写.
举例：将[‘bob’,‘about’,‘zoo’]排序

#!/usr/bin/python3
a=['bob','about','zoo']
b=sorted(a,key=str.lower)
print(b)
输出结果:b=['about','bob','zoo']
#倒序
c=sorted(a,key=str.lower,reverse=True)
print(c)

5.偏函数
当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单.
目的是修改函数的默认值.

#!/usr/bin/python3
#from functools import partial
def fadd(n,m):
	print(n,m)
	return n%m
def partal(f,x):
	f.__defaults__=(x,)
	return f
fadds=partal(fadd,7)
c=fadds(100)
d=fadds(200)
print(c,d)

functools模块
partial方法
偏函数，把函数部分的参数固定下来，相当于为部分的参数添加了一个固定的默认值，形成一个新的函数并返回.从partial生成的新函数，是对原函数的封装.
6.柯里化 Currying
指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数 z = f(x, y) 转换成z = f(x)(y)的形式.

#!/usr/bin/python3
def f(x,y):
return x+y
print(f(3,4)

进行柯里化

def f1(x):
	def f2(y):
		return x+y
	return f2
print(f1(3)(4))

7.装饰器
装饰器思想
装饰器是高阶函数但装饰器是对传入函数的功能的装饰，返回值也是一个函数。可以在不影响原来函数的基础上给函数追加功能。他们有助于让我们的代码更简。
带参装饰器就是外边在加一层函数，返回是不带参装饰器

装饰器缺点
原函数对象的属性都被替换了，而使用装饰器我们需要查看被封装函数的属性时我们可以改造带参装饰器，或者调用系统functools方法，在装饰器外函数下直接写@functools.wraps(fn)即可；建议装饰器都使用 functools 方法。

装饰器实例
1.改造带参装饰器包装函数属性

def lon(fn):
    def inner(f):
        f.__name__ = fn.__name__   #将add信息给wapper
        f.__doc__ = fn.__doc__
        return f                   #返回wapper继续执行
    return inner	
def longer(fn):                    #longer(add)(*args,**kwarges)
    @lon(fn) 			   #等价lon(fn)(wapper)(*args,**kwarges)==inner(wapper)(*args,**kwarges)===wapper(*args,**kwarges)
    def wapper(*args,**kwargs):    #应为它是lon(fn)的语法糖，所以会走@lon(fn)===lon(fn)(wapper)
        """
        :param args:
        :param kwargs
        :return:
        """
        print("I am a wapper")
        print("begin")
        a = fn(*args,**kwargs)
        print("end")
        return a
    return wapper

@longer                            #==longer(add)(*args,**kwarges) 进入longer函数
def add(x,y):
    """"
    tis function is to x + y
    """
    return x+y

print(add.__name__,add.__doc__)     ####直接调用add属性注释会显示wapper属性；用装饰器lon修改
print(add(3,4))                     #走到@longer

2.带参装饰器

from datetime import datetime
import time
def lon(fn):
    def inner(f):
        f.__name__ = fn.__name__
        f.__doc__ = fn.__doc__
        return f            #返回wapper继续执行
    return inner

def longer(n):                #longer(2)(add)
    def iner(fn):             #iner(fn)==wapper
        @lon(fn)              #等价lon(fn)(wapper)==inner(wapper)===wapper
        def wapper(*args,**kwargs): 
            """

            :param args:
            :param kwargs
            :return:
            """
            now = datetime.now().timestamp()
            a = fn(*args,**kwargs)
            delta = datetime.now().timestamp()-now
            if delta>n:
                print("this function {} take more then {} minitines".format(fn.__name__,n))
            return a
        return wapper
    return iner

@longer(2)              #longer(2)(add)(*args,**kwarges)
def add(x,y):
    """"
    tis function is to x + y
    """
    time.sleep(3)
    return x+y

print(add.__name__,add.__doc__)
print(add(3,4))