20201204函数三

高阶函数

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

list1=[1,2,3,4,5,6,7,8,9,10]
def fun2(n):
    if n %2==0:
        return True

def fun(fn): #接受函数做为参数
   list2=[]
   for i in list1:
       if fn(i):
           list2.append(i)
   return list2
print(fun(fun2)) #传递函数对象做为参数

结果:

[2, 4, 6, 8, 10]

匿名函数

匿名的目的就是要没有名字，给匿名函数赋给一个名字是没有意义的
lambda匿名函数：lambda (参数:表达式)(传参)

res=lambda a,b:a+b   #定义了一个a+b求和函数
res(1,2)
print('返回的是lamda的id:',res)
print(res(1,2))
res=(lambda a,b:a+b)(1,2)
print(res)
list1=[1,2,3,4,5,6,7,8,9,10]
def fun2(n):
    if n %2==0:
        return True

结果:

返回的是lamda的id: <function <lambda> at 0x000002632C4808B0>
3
3

filter()过滤函数:有两个参数

1.传递一个函数给他
2.传递一个需要过滤的序列
序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

list1=[1,2,3,4,5,6,7,8,9,10]
def fun2(n):
    if n %2==0:
        return True
print(list(filter(fun2, list1)))
res=lambda a:a % 2 == 0
print(list(filter(res, list1)))

结果:

[2, 4, 6, 8, 10]
[2, 4, 6, 8, 10]

闭包

• 将函数作为返回值也是高阶函数我们也称为闭包
• 闭包的好处

• 通过闭包可以创建一些只有当前函数能访问的变量
• 可以将一些私有数据藏到闭包中

• 行成闭包的条件

• 函数嵌套
• 将内部函数作为返回值返回
• 内部函数必须要使用到外部函数的变量

• 闭包会保持外部变量不被销毁，会增加内存负担，慎用。

def fun_out(num1):
    # 定义一个内部函数
    def fun_inner(num2):
    	nonlocal num1   #告诉解释器，num1为外部分变量
        #内部函数使用外部函数的变量或参数
        res=num1+num2
        print(res)
    return fun_inner

f=fun_out(1)
f(2)
print(fun_out)

结果:

3
<function fun_out at 0x000002632C480B80>

装饰器的引入

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

装饰器的使用

• 通过装饰器，可以在不修改原来函数的情况下来对函数进行扩展
• 在开发中，我们都是通过装饰器来扩展函数的功能的
• 装饰器是一个特殊的闭包
示例1:

def  add(a,b):
    return a+b
# fun是做装饰，不是装饰器
def fun(fn,*args,**kwargs):
    print('程序开始执行')
    r=fn(*args,**kwargs)
    print('程序执行结束')
    return r

print(fun(add,1,2))

结果:

程序开始执行
程序执行结束
3

示例2:

# 装饰器
def fun_out(fn):

    def fun_inner(*args,**kwargs):
        print('程序开始执行')
        r=fn(*args,**kwargs)
        print('程序执行结束')
        return r
    return fun_inner

f=fun_out(add)
res=f(1,2)
print(res)

结果:

程序开始执行
程序执行结束
3

示例3:

def fun_out(fn):
    def fun_inner(*args,**kwargs):
        print('程序开始执行')
        r=fn(*args,**kwargs)
        print('程序执行结束')
        return r
    return fun_inner
@fun_out  #装饰器语法糖的用法
def  add(a,b):
    return a+b
r=add(1, 2)
print(r)

结果:

程序开始执行
程序执行结束
3

#练习代码

import time

def  add(a,b):
    time.sleep(3.14)
    r=0
    for i in range(1000):
        r+=i
        r=a+b+r
    print('fn内打印结果:',r)
    return r
# 装饰器
def fun_out(fn):
    print('程序out开始执行')
    star_time = time.time()
    def fun_inner(*args,**kwargs):
        print('程序inner开始执行')
        r=fn(*args,**kwargs)
        end_time=time.time()
        print('程序inner结束')
        print('程序执行时间%.2f秒'%(end_time-star_time))
        return r
    print('程序out结束')
    return fun_inner

f=fun_out(add)
time.sleep(2)
print('inner执行前延时2秒...,',end='')
res1=f(1,2)
print('res1',res1)
print('res1结束',end='\n\n')
res2=f(3,4)
print('res2',res2)
print('res2结束')

res3=f(5,6)
print('res3',res3)
print('res3结束')

结果:

程序out开始执行
程序out结束
inner执行前延时2秒...,程序inner开始执行
fn内打印结果: 502500
程序inner结束
程序执行时间5.14秒
res1 502500
res1结束

程序inner开始执行
fn内打印结果: 506500
程序inner结束
程序执行时间8.28秒
res2 506500
res2结束
程序inner开始执行
fn内打印结果: 510500
程序inner结束
程序执行时间11.42秒
res3 510500
res3结束