将来的你，一定会感谢现在现在拼命的你——函数三

11——函数三

1.高阶函数

• 接收函数作为参数，或者将函数作为返回值返回的函数就是高阶函数

lst = [1,2,3,4,5,6,7,8,9,20]
#定义一个函数，用来检查一个偶数
def fn2(i):
    if i % 2 == 0:
        return True
#定义一个函数，用来检测是否大于5
def fn3(i):
    if i > 5:
        return True
    return False
#定义一个函数，用来检测是否是3的倍数
def fn4(i):
    if i % 3 == 0:
        return True
    return False
#定义一个函数，可以将制定的列表中所有的偶然，保存到一个新的列表中返回
#当我们使用一个函数作为参数，实际上是指将制定的代码传递进了目标函数
def fn(func,lst):
    #参数lst要进行筛选列表
    #创建一个新的列表
    new_lst = []
    for n in lst:
        #判断n的奇偶
        if func(n):
            new_lst.append(n)
    return new_lst
print(fn(fn4,lst))   #返回结果：[3, 6, 9]

2. 闭包

• 将函数作为返回值也是高阶函数我们也称为闭包
• 闭包的好处
• 通过闭包可以创建一些只有当前函数能访问的变量

def fn():
    a = 10
    #在函数内部定义一个函数
    def fn2():
        print('我是fn2',a)
        #将内部函数作为返回值返回
    return fn2
 # r是一个函数，是调用fn()后返回的函数，这个函数是在fn内部定义，并不是全局函数
r = fn()
r()   #我是fn2 10

• 可以将一些私有数据藏到闭包中

#求多个数的平均值
nums = [50.,20,60,10,80]
#sum()用来求一个列表中元素之和
print(sum(nums)/len(nums))   #44.0

• 行成闭包的条件
• 函数嵌套
• 将内部函数作为返回值返回
• 内部函数必须要使用到外部函数的变量

nums = []
#定义一个函数，计算平均值
def average(n):
    #将n添加到列表当中
    nums.append(n)
    #求平均值
    return sum(nums)/len(nums)
print(average(10))   #10.0
print(average(10))   #10.0
print(average(20))   #13.333333333333334
print(average(20))   #15.0

def make_average():
    nums = []
    #定义一个函数，计算平均值
    def average(n):
        #将n添加到列表当中
        nums.append(n)
        #求平均值
        return sum(nums)/len(nums)
    return average
a = make_average()
print(a(10))  #10.0
nums = []
print(a(20))  #15.0

3. 装饰器的引入

• 我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题
• 如果修改的函数多，修改起来会比较麻烦
• 不方便后期的维护
• 这样做会违反开闭原则(ocp)
• 程序的设计，要求开发对程序的扩展，要关闭对程序的修改

def add(a,b):
    return a + b
#求任意两个数的积
def mul(a,b):
    return a * b
r = add(1,20)
print(r)  #21

def add(a,b):
    print('开始计算')
    print('计算结束')
    return a + b
#求任意两个数的积
def mul(a,b):
    return a * b
r = add(1,20)
print(r)  #开始计算 计算结束 21

4. 装饰器的使用

• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
• 在开发中，我们都是通过装饰器来扩展函数的功能的

def fn():
    print('我是fn函数')
def add(a,b):
    return a + b

def start_end(old):
    #用来对其他的函数进行扩展，扩展函数执行的时候，打印、开始执行，执行后打印执行结束
    #参数 old 要扩展的函数对象
    #创建一个函数
    def new_function(a,b):
        print('开始执行')
        #要调用被扩展的函数
        result = old(a,b)
        print('执行结束')
        return result
    #返回新函数
    return new_function
f = start_end(add)
r = f(1,2)
print(r)

返回结果：

开始执行
执行结束
3

像start_end(old)类似于这样的函数我们就称之为装饰器

def fn():
    print('我是fn函数')
def add(a,b):
    return a + b

def start_end(old):
    #用来对其他的函数进行扩展，扩展函数执行的时候，打印、开始执行，执行后打印执行结束
    #参数 old 要扩展的函数对象
    #创建一个函数
    def new_function(*args,**kwargs):
        print('开始执行')
        #要调用被扩展的函数
        result = old(*args,**kwargs)
        print('执行结束')
        return result
    #返回新函数
    return new_function
f = start_end(add)
r = f(555,666)
print(r)

返回结果：

开始执行
执行结束
1221

def fn():
    print('我是fn函数')
def add(a,b):
    return a + b

def start_end(old):
    #用来对其他的函数进行扩展，扩展函数执行的时候，打印、开始执行，执行后打印执行结束
    #参数 old 要扩展的函数对象
    #创建一个函数
    def new_function(*args,**kwargs):
        print('开始执行')
        #要调用被扩展的函数
        result = old(*args,**kwargs)
        print('执行结束')
        return result
    #返回新函数
    return new_function
f = start_end(add)
r = f(555,666)
print(r)

@start_end
def speak():
    print('大家加油')

speak()   #开始执行  大家加油  执行结束