python 常用的高阶函数

前言
高阶函数指的是能接收函数作为参数的函数或类；python中有一些内置的高阶函数，在某些场合使用可以提高代码的效率．
map()
map函数可以把一个迭代对象转换成另一个可迭代对象，不过在python3中，结果都是一个map对象，它是一个生成器，可以通过next函数获取它的元素；使用map函数的代码效率比for循环和列表生成式都要高。
参数：
一个函数func，可以是任何函数；
一个或多个可迭代对象，可以是元组、集合、列表等；如果函数有多个参数就传入多个可迭代对象；
# 单个参数
p = map(int,{2,3,4,5})

# 多个参数
def add(x,y,z):
    return x+y+z

p1 = map(add,[1,2,3],(4,5,6),{7,8,9}) # 注意如果是集合，顺序是不固定的
# 由于是一个map对象，可以转换为list对象
li = list(p1)
reduce()
reduce函数在python3中被放置到functool模块中了，要使用需要引入；
参数：一个函数f，一个可迭代对象，一个可选的初始值；
功能：通过对函数f的反复调用，可以得到最终的积累结果；
def test5(listx):
    from functools import reduce
    res = reduce(add1,listx)
    print(res)
def add1(x,y):
    return x+y

li = [1,2,4,7,8]
test5(li)
filter()
过滤函数，可以将可迭代对象里的每个元素依次作用于过滤函数，通过返回的false和true对元素进行保留或丢弃；最后返回一个filter对象，该对象是一个生成器；
参数：
func:一个过滤函数，可以是匿名函数；
iterator:一个等待过滤的可迭代对象；
li = [1, 2, 4, 7, 8]
res = filter(lambda x: x % 2 == 1, li)
print(list(res))
max
max内置函数不仅仅是用来获取一个容器中的算术最大值，事实上它可以自定义比较的规则。
# 参数：
key:比较的规则
values:比较值
x = max(['name','age','you'],key=lambda x:len(x))
print(x) # name
y = max('name','age','you',key=lambda x:len(x))
print(y) # name
min
用来获取一个容器中的最小值，用法参考max.
sorted
sorted函数用来对容器里的元素进行重新排序并返回一个新的容器，支持自定义比较规则。
# 参数
key：比较规则；
reverse：排列规则，默认False，升序排列
values:第一个参数必须是一个容器
x = sorted(['name','age','you'],key=lambda x:len(x),reverse=False)
print(x)
partial
偏函数partial是一个类，有时候一些函数在使用的时候要求不能有参数或者为了少传递参数，典型的如flask框架中的session和g等代理对象的创建，这时可以将函数转化成偏函数；它的原理是将函数的对象和参数作为参数生成一个partial对象，调用时传入的新参数和对象存储的参数合并后再调用原来的函数，即将传参分成两步完成。
from functools import partial, partialmethod
new_func = partial(get_values, *(2,3)) # 第一步先传两个参数，注意需要解包
print(new_func(4)) # 再传最后一个参数
总结
partial类的作用就是将一个函数执行拆成两步：先传参后执行或先传部分参，后再传参调用执行；
sorted方法对容器元素按照指定的规则排序；
max和min方法按照指定的比较规则选出容器的最大最小值；
filter类对容器元素进行过滤；
reduce方法对元素迭代积累；
map类按照自定规则将容器里的所有元素转化成另外的元素值得到一个新的容器；

、函数式编程
函数本身可以赋值给变量，赋值后变量为函数；
允许将函数本身作为参数传入另一个函数；
允许返回一个函数。
1、map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回
def add(x):
    return x+x

print map(add,[1,2,3])
 
 
2、reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。
1 def prod(x, y):
2     return x*y
3 
4 print reduce(prod, [2, 4, 5, 7, 12])
reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：
计算初始值和第一个元素：f(100, 1)，结果为101。
 
3、filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新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，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

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)

sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较。

def cmp_ignore_case(s1, s2):
    s1=s1.lower()
    s2=s2.lower()
    if s1>s2:
        return 1
    if s1<s2:
        return -1
    return 0

print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

 5、Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！
请注意区分返回函数和返回值：
def myabs():
    return abs   # 返回函数，返回函数可以把一些计算延迟。
def myabs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值

def calc_prod(lst):
    def lazy_prod():
        prod=1
        for i in lst:
            prod=prod*i
        return prod
    return lazy_prod
f = calc_prod([1, 2, 3, 4])
print f()

高阶函数：就是把函数当成参数传递的一种函数；

示例：


 def add(x,y,function):
        return function( x)+ function( y)
    print (add(-3,5,abs))

注解：

1.调用add函数，分别执行abs(-3)和abs(5),分别计算出他们的值

2.最后在做和运算，最终结果输出是8


 

map（）函数


    格式：map(func, iter)
    
    
    说明：

    
        接收两个参数：一个函数和一个可迭代对象
        
        
        返回值：返回一个生成器
        
        
        生成器内容是将func依次作用域iter每个元素的处理结果
        
    
 示例：


 

def func(x):
    return x * x
print map(func,[1,2,3,4,5]) 

注解：
1.list里的每个元素都会走一遍f(x)方法
2.输出结果是[1,4,9,16,25]



 

filter( )函数


    格式：filter(func, iter)
    
    
    说明：

    
        参数是一个函数和一个可迭代对象
        
        
        返回一个生成器
        
        
        将func依次作用于iter中的元素，返回值为真的将会保留，为假的将会过滤掉
        
    
    
    示例：
    

 

lt = [1, 2, 3, 4, 5]

# 提取偶数
f = filter(lambda x: x%2==0, lt)
print(list(f))

注解：lt中数据会走一遍匿名函数就是除以2余数为零，然后filter过滤符合要求（偶数）的打印出来，不符合要求的过滤掉 

输出结果为 2,4

 


 

reduce（）函数


    格式：reduce(func, iter)
    
    
    说明：

    
        接收两个参数，一个函数和一个可迭代对象
        
        
        首先取前两个元素作为func的参数，计算完的结果与第三个元素继续使用func处理，直至结束
        
        
        返回处理的最后结果
        
    
示例：


 

from functools import reduce

lt = [1, 2, 3, 4, 5]

# 求和
# s = reduce(lambda x,y: x+y, lt)
# 转换为12345
s = reduce(lambda x,y: x*10+y, lt)
print(s)

输出结果为12345


 

sorted（）函数

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：

iterable -- 可迭代对象。
    cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
    key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
示例： 


print(sorted([1,5，9，8，3]))

输出结果为 [1,3,5,8,9]
---------------------