第十课 函数下 高阶函数

高阶函数

• 接收函数作为参数
• 将函数作为返回值返回的函数就是⾼阶函数
  (满足上面任意条件 ，就是高阶函数 )

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]    #这个不是高阶函数
def fun(lst):
    new_list=[]
    for i in lst:
        if i %2==0:
            new_list.append(i)
    return new_list
print(fun(list1))

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]  #这个不是高阶函数,因为没有函数传递

def fun(lst):
    def fun1(n):
        if n % 2 == 0:
            return True

    new_list = []

    for i in lst:
        if fun1(i):
            new_list.append(i)
    return new_list

print(fun(list1))

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

def fun1(n):
    if n % 2 == 0:
        return True

def fun2(n):
    if n>5:
        return True

def fun(lst , fn):

    new_list = []
    for i in lst:
        if fn(i):
            new_list.append(i)
    return new_list
print(fun(list1,fun1))
print(fun(list1,fun2))

匿名函数

概念

• python 使用 lambda 来创建匿名函数。
• lambda只是一个表达式，函数体比def简单很多。
• 用于做一些简单的运算，而不用定义函数
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

res = (lambda a,b:a+b)(1,2)  #可以用作一些简单的运算，不用定义函数
print(res)

def fun():    
    def fun1():
        pass
    return fun1
print(fun())

闭包

• 将函数作为返回值也是⾼阶函数，我们也称为闭包
• 闭包的好处
• • 通过闭包可以创建⼀些只有当前函数能访问的变量
• • 可以将⼀些私有数据藏到闭包中
• ⾏成闭包的条件
• • 函数嵌套
• • 将内部函数作为返回值返回
• • 内部函数必须要使⽤到外部函数的变量

#设计一个函数，赋值一个变量，可以在这个变量的基础上每次和不同的数字进行相加

def fun_out(num1):
    def fun_inner(num2):
        res = num1+num2
        return res
    return  fun_inner       #不带括号就是函数  带括号就是函数调用

r=fun_out(3)   #fun_out(1)=fun_inner
print(r(2))    #fun_out(1)()=fun_inner()    
                 

#设计一个函数，赋值一个变量，可以在这个变量的基础上每次和不同的数字进行相加
def fun_out(num1):
    def fun_inner(num2):
        nonlocal num1        #告诉解释器，此处的变量非本地变量。外部变量会因此而改变
        #global num1
        num1=10
        res = num1+num2
        return res
    print(num1)
    fun_inner(1)
    print(num1)
    return  fun_inner

r=fun_out(1)   #fun_out(1)=fun_inner
r(2)    #fun_out(1)()=fun_inner()

#nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量。
def nonlocal_test():
    count = 0

    def test2():
        nonlocal count
        count += 1
        return count

    return test2


val = nonlocal_test()
print(val())
print(val())
print(val())

#nonlocal  会改变外部嵌套变量值

装饰器

开闭原则：Open Closed Principle, OCP

• Software entities like classes, modules and functions should be open for extension but closed for modifications.(一个软件实体如类，模块和函数应该对扩展开放，对修改关闭。）
• 软件实体应该对扩展开放，对修改关闭，其含义是说一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。
• • 一般装饰器

#一般装饰器
def add(a,b):
    return a+b

def mul(a,b):
    return a*b

def fun():
    print('程序开始执行了')
    print(add(1, 2))
    print('程序执行结束了')

fun()

• • 通用装饰器

def fun_out(old):
    def fun_inner(*args,**kwargs):    #不定长参数传递
        print('程序开始执行了')
        print(old(*args,**kwargs))
        print('程序执行结束了')
    return fun_inner


def add(a,b):
    return a+b

def fun1():
    print('我是fun1')

def mul(a,b):
    return a*b

r= fun_out(fun1)
r()

语法糖

def fun_out(old):
    def fun_inner(*args,**kwargs):
        print('程序开始执行了')
        print(old(*args,**kwargs))
        print('程序执行结束了')
    return fun_inner

@fun_out
def add(a,b):
    return a+b
add(1,2)

@fun_out
def fun1():
    print('我是fun1')
fun1()

@fun_out
def mul(a,b):
    return a*b
mul(3,4)

作业

• 请使用装饰器实现一存在函数的执行所花费的时间
  .time模块

import time

def waste_time(fun):
    def inner():
        star=time.time()
        fun()
        end=time.time()
        print(end-star)
    return inner

@waste_time
def fun1():
    for i in range(1,1000000):
        pass
fun1()