函数（3）

函数（3）

---

高阶函数

判断是否是高阶函数的两个条件

• 是否以函数作为参数
• 是否以函数作为返回值

# 判断一个函数是高阶函数的两个条件
# 1. 这个函数以函数作为参数
# 2. 这个函数的返回值是函数对象

# lst = [1,2,3,4,5,6,7,8,9,10]
#
# def fn1(i):
#     if i % 2 == 0:
#         return True
#     return False
#
# def fn2(i):
#     if i % 3 == 0:
#         return True
#     return False
#
# def fn3(i):
#     if i > 5:
#         return True
#     return False
#
# def fn(func,lst):
#
#     new_lst = []
#
#     for i in lst:
#
#         if func(i):
#             new_lst.append(i)
#
#     return new_lst
#
# print(fn(fn1,lst))

匿名函数

语法：lambda 参数列表：返回值

lambda只能用来创建简单的函数

# lst = [1,3,5,7,9]
# f = filter(lambda i : i % 3 == 0, lst)
# print(list(f))

# def fn(i):
#
#      if i % 3 == 0:
#         return True
#      return False
# 这个函数相当于lambda i : i % 3 == 0
#
# f = filter(fn,lst)
# print(list(f))

• lambda相当于定义一个函数
• filter(function,iterable)是一个高阶函数，有两个参数：函数和可迭代对象。
• filter()函数的作用是过滤器，依次将可迭代对象中的元素放进function中作为参数，然后返回是True的元素。
• 匿名函数的好处是在调用完一次后就会在内存中消失

---

闭包

闭包也是一种高阶函数

判断是否闭包的三个条件：

• 是否函数嵌套
• 内部函数是否引用外部函数的变量
• 是否以内部函数作为返回值

# 定义一个函数，用来计算多个数的平均数
# nums = []
# def fn1(n):
#
#     nums.append(n)
#     return sum(nums)/len(nums)
#
# print(fn1(10))
# nums = []    # 影响了结果，这个nums和上面的nums有关系
# print(fn1(20))

# 闭包
# def fn():
# 
#     nums = []
# 
#     def fn1(n):
#         nums.append(n)
#         return sum(nums)/len(nums)
# 
#     return fn1
# 
# r = fn()
# print(r(10))
# nums = []    # 对结果没有影响，说明这个nums和函数内的nums没有关系，说明闭包能够保护数据
# print(r(20))

闭包的好处：

• 可以创建只有当前函数可以访问的变量
• 可以将私有的重要的数据藏在闭包里

---

装饰器的引入

# def add(a,b):
#     r = a + b
#     print(r)
# 
# def mul(a,b):
#     r = a * b
#     print(r)

当我们对上面的两个函数进行扩展时，可以在每个函数的内容进行扩展。

但是这样会存在一些问题：

1. 如果函数过多，一个个进行扩展会显得麻烦且浪费时间
2. 后期不易于进行维护
3. 违背了ocp原则：开放对函数的扩展，关闭对函数的修改

针对这三个问题，我们通过创建一个新的函数来对原函数在不修改的基础上进行扩展

# def fn():
#     print('函数开始执行')
#     r = add(1,2)
#     print('函数结束执行')
#
# fn()
# 这样就扩展了add函数

# 同理可以扩展mul函数
# def fn():
#     print('函数开始运行')
#     r = mul(1,2)
#     print('函数结束运行')
#
# fn()
# 这样就扩展了mul函数

---

装饰器的使用

# def plus(x,y):
#     return x+y
# def minus(x,y):
#     return x-y
# def say():
#     return 'I Love You'
#
# def fn(old):
# 
#     def new_function(*args,**kwargs):
#         print('函数在执行')
#         r = old(*args,**kwargs)
#         print('函数结束执行')
#         return r
# 
#     return new_function

# f = fn(plus)
# print(f(1,2))
# f = fn(say)
# print(say())

在装饰器的引入中，我们通过定义一个新的函数对原函数进行了扩展。

这个新的函数我们称之为装饰器。通过装饰器，我们可以在不修改原函数的基础上扩展原函数。在开发中，我们都用装饰器来扩展函数功能

我们通过 @装饰器名称 来给原函数添加装饰器

# @ fn
# def mul(x,y):
#     return x*y
#
# print(mul(1,2))

效果和上面的相同

---

以上为个人总结+资料收集，欢迎各位进行批评指正~