第10讲 函数（下）

高阶函数

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

list1 = [1,2,3,4,5,6]
list2 = []
list3 = []
def num(f):
    if f % 2 ==0:
        return True

def num2(n):
    if n >= 3:
        return True

def num1(fn,x,y):    #接受函数作为返回值
    for i in x:
        if fn(i):    #外部定制一个函数
            y.append(i)
    return y

print(num1(num,list1,list2))
print(num1(num2,list1,list3))

匿名函数（lambad函数）

• lambda函数的用法 参数：表达式
• 专门用来创建一些简单的函数，替代原函数写法

# lambda函数的用法 参数：表达式
def num(f):     #常规函数写法，简单函数用匿名函数替代
    if f % 2 ==0:
        return True
    
num1 = lambda i : i%2==0   #i为形参，‘：’后边的为需要对传参进行运算的表达式
print(num(2))   
print(num1(2))   #2为实参传参进num1这个匿名函数中，结果同于num函数

结果：

filter类

• 需要传递两个参数（按照特定的规则，过滤出想要的数据）
  1.传递一个函数
  2.传递一个需要过滤的序列（可迭代的）

list1 = [1,2,3,4,5,6,7,8]
# lambda函数的用法 参数：表达式
num1 = lambda i : i%2==0   #i为形参，‘：’后边的为需要对传参进行运算的表达式

# # filter类的用法:filter(函数，可迭代的参数)，通过函数过滤可迭代的参数
n = filter(num1,list1)   #引用num1函数，过滤list1这个列表
print(list(n)) #通过list（）导出filter中的数据

结果：

闭包

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

def func_outside(num1):

    def func_inside(num2):   #条件1：函数嵌套
        result = num1 + num2   #条件3：内部函数必须用到外部函数的变量
        return result

    return func_inside   #条件2：将内部函数做为返回值返回


a = func_outside(10)
print(a(2))
print(a(5))    #外部函数的变量不会被回收

结果：

def func_outside(num1):

    def func_inside(num2):   
        nonlocal num1    #声明num1为外部变量
        num1 = 20    #如果没有上边的声明，此处就变成了重新赋值
        result = num1 + num2   
        print(result)
    print(num1)      #未调用内部函数，此时变量依然为10
    func_inside(1)    #函数内调用内部函数，函数num1被改变
    print(num1)     #因有nonlocal声明，外部函数随之改变
    return func_inside   


a = func_outside(10)

结果

装饰器的引入

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

# 装饰器的引入
def num1(a, b):
    return a + b


def num2(c, d):
    return c * d


def fun(fn, *args, **kwargs):
    print('程序开始')
    r = fn(*args, **kwargs)     #装饰任一函数
    print(r)
    print('程序完毕')
    return r


i = fun(num1, 10, 5)
j = fun(num2, 20, 5)

达到装饰效果，但不是闭包，并未达成完整的装饰器

装饰器

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

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


def num2(c, d):
    return c * d


def fun_outside(fn, *args, **kwargs):

    def fun_inside():
        print('程序开始')
        r = fn(*args, **kwargs)     
        print(r)
        print('程序完毕')
        return r
    return fun_inside        #闭包，此时为完整的装饰器


i = fun_outside(num1, 10, 5)
i()

结果

如果需要使用此种装饰器的函数较多，在装饰其中逐一添加函数，不适合使用习惯，应该有一个装饰器，需要进行调用的时候就可以用

def fun_outside(fn, *args, **kwargs):

    def fun_inside(*args, **kwargs):
        print('程序开始')
        r = fn(*args, **kwargs)
        print(r)
        print('程序完毕')
        return r
    return fun_inside


@fun_outside   #语法糖
def num1(a, b):
    return a + b


num1(2, 8)


@fun_outside   #语法糖
def num2(c, d):
    return c * d


num2(3, 7)

结果：

---

作业

请使用装饰器实现已存在的函数的执行所花费的时间。

import time


def time_out(fn, *args, **kwargs):     #计时装饰器

    def time_in(*args, **kwargs):
        start = time.clock()
        r = fn(*args,**kwargs)
        end = time.clock()
        consume_time = end - start
        return consume_time
    return time_in


@time_out
def count(n):
    list1 = []
    for i in range(n+1):
        list1.append(i)
    return list1


x0 = count(3141)
x1 = count(31415)
x2 = count(314159)
x3 = count(3141592)
x4 = count(31415926)
print(x0)
print(x1)
print(x2)
print(x3)
print(x4)

结果：