python高阶函数 —— 内置高阶函数、返回值为函数、函数作为参数、闭包

一、什么是高阶函数？

高阶函数：接收函数作为参数，或者将函数作为返回值的函数是高阶函数。
当我们使用一个函数作为参数时，实际上是将指定的代码传递进了目标函数。

参数为函数

# 创建一个列表
l = [1,2,3,4,5,6,7,8,9,10]

def fn(func , lst) :
    '''
        fn()函数可以将指定列表中的所有偶数获取出来，并保存到一个新列表中返回
        参数：
            lst：要进行筛选的列表
    '''
    # 创建一个新列表
    new_list = []

    # 对列表进行筛选
    for n in lst :     
        if func(n) :
            new_list.append(n)
    # 返回新列表
    return new_list

# 被2整除
def fn2(i) :
    if i % 2 == 0 :
        return True
    return False    

# 这个函数用来检查指定的数字是否大于5
def fn3(i):
    if i > 5 :
        return True    
    return False

# 能否被3整除
def fn4(i):
     if i % 3 == 0:
         return True    
     return False
        
print(fn(fn2 , l))   # 过滤被2整除的列表
print(fn(fn3 , l))   # 大于5的列表
print(fn(fn4 , l))   # 被3整除的列表

返回值为函数

# 返回值为函数
def bar():
    print("in the bar..")
    
def foo(func):
    print("in the foo..")
    return bar # 此返回值是bar
    
res=foo(bar)

res()

以上两个示例中，函数foo()为高阶函数，示例一中函数bar作为foo的参数传入，示例二中函数bar作为foo的返回值。

注：

函数名（例如bar 、foo）–>其为该函数的内存地址；函数名+括号（例如 bar()、foo() )–>调用该函数。

二、 高阶函数1（函数作为参数）

2.1、 python 内置高阶函数（函数作为参数）

map、filter、reduce、sort、sorted

1） filter() 过滤出符合条件的元素

filter() 可以从序列中过滤出符合条件的元素，保存到一个新的序列中 。

参数：
1.函数，根据该函数来过滤序列（可迭代的结构）

​ 2.需要过滤的序列（可迭代的结构）

返回值：

​ 过滤后的新序列（可迭代的结构）

l = [1,2,3,4,5,6,7,8,9,10]

r = filter(lambda i : i > 5 , l)
print(list(r))

运行结果：

[6, 7, 8, 9, 10]

2） map() 对所有元素做指定的操作

map()函数可以对可迭代对象中的所有元素做指定的操作，然后将结果添加到一个新的对象中返回。

l = [1,2,3,4,5,6,7,8,9,10]

r = map(lambda i : i ** 2 , l)

print(list(r))

3） reduce() 合并

reduce函数的第1个参数为函数，其返回值为一个值，一般用于叠加、叠乘等。

参数说明：

• 第1个参数： 函数
• ​ 第2个参数： 队列
• ​ 第3个参数： 初始值，默认为0

# reduce函数不是内置函数，而是在模块functools中的函数，故需要导入
from functools import reduce

nums=[1,2,3,4,5,6]

# reduce 函数的机制
def reduce_test(func,array,initVal=None): # initVal 作为初始值，默认为0
    if initVal == None:
        result =array.pop(0) # 如果为空时，默认为0
    else:
        result = initVal
    for i in array:
        result = func(result,i)
    return result

# 叠加
print(reduce_test(lambda x,y:x+y,nums,1))


#reduce函数，叠加
print(reduce(lambda x,y:x+y,nums,1))

运行结果：

22

4） sort() 排序

该方法用来对列表中的元素进行 排序

sort()方法默认是直接比较列表中的元素的大小
在sort()可以接收一个关键字参数 ， key
key需要一个函数作为参数，当设置了函数作为参数

每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小

l = ['bb','aaaa','c','ddddddddd','fff']
l2=l.sort(key=len)       # len() 方法的返值来排序，即字符串的长度排序

print(l)
print(l2)

运行结果：

['c', 'bb', 'fff', 'aaaa', 'ddddddddd']
None

l3 = [2,5,'1',3,'6','4']
l4 = l3.sort(key=int) # 根 int() 函数的返回值来排序，即将所有的值转换成数字，根数值的大小排序
print(l3)
print(l4)

运行结果：

['1', 2, 3, '4', 5, '6']
None

从运行结果得知： sort() 没有返回值

5） sorted() 排序

这个函数和sort()的用法基本一致，但是sorted()可以对任意的序列进行排序
并且使用sorted()排序不会影响原来的对象，而是返回一个新对象

l = [2,5,'1',3,'6','4']
# l = "123765816742634781"
l2=sorted(l,key=int)

print('排序前:',l)
print('排序后 l:',l)
print('排序后 l2:',l2)

运行结果：

排序前: [2, 5, '1', 3, '6', '4']
排序后 l: [2, 5, '1', 3, '6', '4']
排序后 l2: ['1', 2, 3, '4', 5, '6']

2.2、普通的高阶函数（函数作为参数）

三、 高阶函数2（函数作为 返回值）—— 闭包

闭包的特点：

• 将函数作为返回值返回，也是一种高阶函数；
• 这种高阶函数我们也称为叫做闭包，通过闭包可以创建一些只有当前函数能访问的变量；
• 可以将一些私有的数据藏到的闭包中；

3.1、 形成闭包的必要条件

（1）函数嵌套
（2）将内部函数作为返回值返回
（3）内部函数必须要使用到外部函数的变量

求多个数的平均值：

def make_averager():

    # 创建一个列表，用来保存数值。
    nums = []

    # 创建一个内部函数，用来计算平均值。符合（1）
    def averager(n) :
        # 将n添加到列表中。符合（3）
        nums.append(n) 
        # 求平均值
        return sum(nums)/len(nums)
    
    return averager    # 符合 （2）

调用：

averager = make_averager()  # 返回的参数 averager 是一个函数

print(averager(10))
print(averager(20))
print(averager(30))
print(averager(40))

运行结果：

10.0
15.0
20.0
25.0