Python高阶函数学习总结(map,filter,reduce,递归函数简介,闭包函数)

1、高阶函数定义

函数的入参或返回值中有函数，就可以成为高阶函数
入参中有函数的：

返回值中有函数的:

def func1():
    print('正在执行func1')
def func2():
    print('正在执行func2')
    return func1
res=func2()
res()   #注意调用，调用返回值的函数
#func2()()   #或者写成这种格式，直接调用

参数和返回值都有函数的：

def func1():
    print('正在执行func1')
def func2(func): #入参有函数名
    func()   #参数传入函数名，即调用对应的函数
    print('正在执行func2')
    return func3  #返回值有函数名
def func3():
    print('正在执行func3')

func2(func1)()

2、map函数(循环函数)

map函数作用：对给定序列中的每个元素都应用一个函数操作
map(func,*iterable)–>map对象
map函数本身是个迭代器，第一个参数是函数，注意是函数名，可以是自定义的，也可以lambda，后面的参数是序列，可以传入多个，返回一个map 对象

示例1，参数是一个序列

def self_pow(x):
    return 2**x
m=map(self_pow,[1,2,3,4])  #调用map函数
print('m的值是{}'.format(m))
print('将m收集到列表中是{}'.format(list(m)))

示例2，参数是一个字符串

print(list(map(str.upper, 'abcd')))  #将所有字符转成大写
-->['A', 'B', 'C', 'D']

示例3，参数是多个序列，则并行取出每个序列中对应的元素，然后传给函数的参数

aa=list(map(pow,[1,2,3],[2,3,4]))
print(aa)
-->[1, 8, 81],第一次取出序列1的第一个元素1，同时取出序列2的第一个元素2，计算pow(1,2),第二次分别取两个元素的第二个元素，计算pow(2,3)，第三次计算pow(3,4)

示例4，第一个参数是lambda

m=map(lambda x:x*3,[2,3,4])
print(list(m))
-->[6, 9, 12]

map函数总结
1、map自身返回的就是迭代器，也就是说它自己是自己的迭代器
2、map是迭代操作，所以它的工作方式是惰性的，按需一次返回一个数据，而不是收集完所有数据后一次性返回
3、所有map操作都能替换成等价的for循环，但map的效率比for要高很多，基本能和解析操作的效率差不多
4、如果map中使用了lambda，则map效率低于列表解析，如果map中没有lambda，则效率要稍高于列表解析，所以能用列表解析就用列表解析

3、filter函数(过滤函数)

filter函数作用：从可迭代对象中筛选出元素被函数操作后True的元素
filter(function or None,iterable) -->filter object,第一个参数是函数或None，第二个参数是可迭代序列，返回一个可迭代对象

1、当第一个参数为None时，表示直接从可迭代对象总取出元素为True的元素

print(list(filter(None, ["a", "", 0, "c"])))
-->['a', 'c']

2、第一个参数是lambda函数，筛选出列表中字符串元素产股大于2的字符串

L=['a','bbb','skfj','dd']
L1=filter((lambda x:len(x)>2),L)
print(L1)
---><filter object at 0x00000176BF043FD0>
    ['bbb', 'skfj']

4、reduce函数(累积函数)

需要先引入 functools.reduce
用法：reduce(func,sequence,initial) -->value,initial为可选参数

reduce过程：
1、如果没有initial参数，先从sequence中取两个元素，作为func的参数，然后返回结果A；然后再从seq中取一个元素，和结果A一起作为func的参数，再返回结果B；重复此过程，直到迭代完seq中所有元素，最终返回一个结果

2、如果有initial参数，则先从sequence中取一个元素，和initial一起作为func的参数，返回结果A；然后再从seq中取一个元素，和结果A一起作为func的参数，然后和没有initial时一样遍历完seq中所有元素，最终返回一个结果

3、如果给定了initial，没有给sequence，则initial作为直接返回的默认值
示例:

from functools import reduce

print(reduce(lambda x,y:x+y,[1,2,3,4,5]))
print(reduce(lambda x,y:x if x>y else y,[3,4,2,8,10]))

5、递归函数

在函数内部，调用自己，就是递归函数
必须有一个明确的结束条件；每次进入更深一层递归时，问题 规模都要有所减少；递归效率不高，如果层次过多会导致栈溢出
–需要做递归练习题，后面需要补充专项总结

6、闭包函数

内层函数运用了外层函数的变量，外层函数的返回值是内层函数的引用，这就构成了一个闭包
返回的是内层函数的引用 需要先调用外层函数()，再加个()相当于执行内层函数
闭包函数常用语实现装饰器(装饰器的本质就是闭包)

def outer(a):  #定义外层函数
	b=10
	def inner():  #定义内层函数
		print(a+b)   #内层函数使用外层函数的变量
	return inner   #返回内层函数的引用


demo=outer(5) #demo存的是外函数的返回值，也就是inner函数的引用
demo()  #这里相当于执行inner函数