python之高阶函数、闭包详细介绍

1 高阶函数

• 函数本身可以赋值给变量，赋值后变量为函数；
• 允许将函数本身作为参数传入另一个函数；
• 允许返回一个函数。

'''
# 高阶函数
# 第一个特点 接收一个或者多个函数作为参数
# 第二个特点 将函数做为返回值返回
# 当我们使用一个函数作为参数，实际上是指将制定的代码传递进了目标函数
'''

lst = [1,2,3,4,5,6,7]

# 定义参数函数（判断是否为偶数的函数）
def fn1(i):
    if i%2 ==0:
        return  True

# 定义参数函数（判断是否为奇数的函数）
def fn2(i):
    if i%2 !=0:
        return  True

#定义接受参数函数的函数，实现多个功能
def fn3(func,n):
    num = []
    for i in n:
        if func(i) == True:
            num.append(i)
    return num

print(fn3(fn1,lst))

2 匿名函数

2.1 匿名函数的基本调用

匿名函数定义结束之后，需要一个变量接收，才能在随后的调用中，完成逻辑计算。在开发过程如果需要使用到简单的逻辑计算，不妨使用匿名函数来代替。

'''
匿名函数的语法:
lambda [参数1，参数2，...]：逻辑表达式
匿名函数定义结束之后，需要一个变量接收，才能在随后的调用中，完成逻辑计算。
在开发过程如果需要使用到简单的逻辑计算，不妨使用匿名函数来代替。
'''

# 传统函数:
def fn(x,y):
    return x+y

print(fn(1,2))  # 结果为3

# 匿名函数:
a = lambda x,y:x+y  # 定义匿名函数
print(a(1,2)) # 结果为3

2.2匿名函数的高级调用

匿名函数作为一个参数传入，这样方便我们在调用函数的时候，随时可以修改匿名函数的逻辑表达式，来满足逻辑需求。

'''
匿名函数的高级调用:
把匿名函数作为一个参数传入，这样方便我们在调用函数的时候，随时可以修改匿名函数的逻辑表达式，来满足逻辑需求。
'''
def fn(x,y,test):
    result = test(x,y)
    return result

print(fn(1,2,lambda x,y: x+y))  # 结果为3

# 动态调用匿名函数
func = input('请输入匿名函数的格式: ')
func_new = eval(func)
answer = fn(3,2,func_new)
print(answer)  # 请输入匿名函数的格式: lambda x,y: x*y 6

3 python内置高阶函数

3.1 map函数

map函数：map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

'''
内置高阶map函数：map()函数接收两个参数，一个是函数，一个是序列，
map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
'''
a = list(map(abs,[-1,2,-3,4]))  # abs为python内置的绝对值函数abs()
print(a) # 结果为：[1, 2, 3, 4]

def fn(i):
    if i%2 == 0:
        return i

b = list(map(fn,[1,2,3,4]))  # abs为python内置的绝对值函数abs()
print(b) # 结果为：[None, 2, None, 4]

3.2 reduce函数

reduce函数：reduce把一个函数作用在一个序列[x1,x2,x3…]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做计算。

'''
 内置高阶reduce函数：reduce把一个函数作用在一个序列[x1,x2,x3...]上，
 这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做计算。
'''

from functools import  reduce
def fn(x,y):
    return x+y

print(reduce(fn,[1,2,3,4]))  # 累计求和，为10

3.3 filter函数

filter函数：filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

'''
filter函数：filter()也接收一个函数和一个序列。
和map()不同的是，filter()把传入的函数依次作用于每个元素，
然后根据返回值是True还是False决定保留还是丢弃该元素。
'''

def fn(i):
    return i % 2 == 0
print(list(filter(fn,[1,2,3,4,5,6,7])))  # 结果为[2, 4, 6]
print(list(map(fn,[1,2,3,4,5,6,7])))  # 结果为[False, True, False, True, False, True, False]

3.4 sorted函数

sorted函数提供原地排序(变量排序后，变量本身改变),sorted排序后返回一个新的列表，并不改变原有变量

'''
对列表依照不同类型排序
'''
info = [
# 商品名称  商品数量 商品价格
('apple3',200,32),
('apple4',40,12),
('apple1',40,2),
('apple2',1000,23),
]

print(sorted(info))  # 依靠商品名称,排序[('apple1', 40, 2), ('apple2', 1000, 23), ('apple3', 200, 32), ('apple4', 40, 12)]

def sorted_by_count(x):
    return x[1]
def sorted_by_price(x):
    return x[2]
def sorted_bu_count_price(x):
    return x[1],x[2]

#按照商品的数量进行排序，key代表排序的关键字
print(sorted(info,key=sorted_by_count))  #  依靠商品的数量进行排序 [('apple4', 40, 12), ('apple1', 40, 2), ('apple3', 200, 32), ('apple2', 1000, 23)]
print(sorted(info,reverse=True,key=sorted_by_count))

#按照商品的价格进行排序
print(sorted(info,key=sorted_by_price)) #  依靠商品的价格进行排序[('apple1', 40, 2), ('apple4', 40, 12), ('apple2', 1000, 23), ('apple3', 200, 32)]
print(sorted(info,reverse=True,key=sorted_by_price))

#如果数量一致，按照价格排序
print(sorted(info,key=sorted_bu_count_price)) # 如果数量一致，按照价格排序 [('apple1', 40, 2), ('apple4', 40, 12), ('apple3', 200, 32), ('apple2', 1000, 23)]
print(sorted(info,reverse=True,key=sorted_bu_count_price))

'''
对于字典里面嵌套字典进行排序
'''

d = {'003':{'name':'apple1','count':100,'price':10,},'002':{'name':'apple1', 'count':200,'price':2}}

print(d.items()) # dict_items([('003', {'name': 'apple1', 'count': 100, 'price': 10}), ('002', {'name': 'apple1', 'count': 200, 'price': 2})])
print(sorted(d.values(),key=lambda x:x['count'])) # [{'name': 'apple1', 'count': 100, 'price': 10}, {'name': 'apple1', 'count': 200, 'price': 2}]
from operator import itemgetter
print(sorted(d.values(),key=itemgetter('price'))) # [{'name': 'apple1', 'count': 200, 'price': 2}, {'name': 'apple1', 'count': 100, 'price': 10}]

内置函数介绍参考博文：Python之高阶函数

4 闭包

4.1 基本介绍

（1）定义：将函数作为返回值返回，我们称为闭包
（2）条件
形成闭包的条件：
1.函数嵌套
2.将内部函数作为返回值返回
3.内部函数必须要使用到外部函数的变量
（3）打印闭包
显式地查看“闭包”用 closure， __closure__属性返回的是一个元组对象，包含了闭包引用的外部变量。
若主函数内的闭包不引用外部变量，就不存在闭包，主函数的_closure__属性永远为None：
若主函数没有return子函数，就不存在闭包，主函数不存在_closure__属性，会# 抛出异常。

4.3 使用方法

'''
# 形成闭包(inner_func)的条件
# 1.函数嵌套
# 2.将内部函数作为返回值返回
# 3.内部函数必须要使用到外部函数的变量(自由变量:free variable)
打印闭包采用.__closure__
'''

def fn():
    a = 10 # a为自由变量 free variable
    def fn2():
        print('我是内部函数',a)  # 内部函数,函数嵌套
    return fn2  # 内部函数作为返回值返回

f = fn()  #
f()  # 我是内部函数 10
# print(a)  # 报错:NameError: name 'a' is not defined,说明f不是全局函数,a也不是全局变量
print(fn().__closure__)  # (<cell at 0x000001A93062C7F8: int object at 0x00007FFA9227A2B0>,)

'''
闭包的应用:
# 通过闭包可以创建一些只有当前函数能访问的变量
# 可以将一些私有数据藏到闭包中
'''
# 定义一个用户输入的数字,并存储用户数字里面的偶数
def fn():
    num = []
    def fn2(n):
        if n%2 ==0:
            num.append(n)
        return num
    return fn2

chen = fn()  # chen用户
print(chen(2))  # [2]
print(chen(4))  # [2, 4]
print(chen(6))  # [2, 4, 6]
print(chen(7))  # [2, 4, 6]

zhu = fn()  # zhu用户
print(zhu(21))  # []
print(zhu(4))  # [4]
print(zhu(16))  # [4, 16]
print(zhu(17))  # [4, 16]

深入理解闭包，可以阅读这篇博文：通俗的理解闭包 闭包能帮我们做什么？