Dsh010 python基础编程--函数（下）

1、高阶函数

1.1 高阶函数简介

• 接收一个或多个函数作为参数，或者将函数作为返回值返回的函数就是⾼阶函数
• 当使用一个函数作为参数的时候，实际上是将指定的代码传递到了目标函数

ex1：将指定列表中的偶数提取出来，形成一个新的列表

lst = [1,2,3,4,5,6,7,8,9,10]
def fn(L):
    # 参数L是被指定的列表
    new_lst = []
    for n in L:
        if n % 2 == 0:
            new_lst.append(n)
    return new_lst
print(fn(lst))         # 输出结果为：[2, 4, 6, 8, 10]

ex2：根据用户需求解函数值

lst = [1,2,3,4,5,6,7,8,9,10]
def fn2(i):
    if i % 2 == 0:      # 求偶数
        return True
def fn3(i):
    if i > 5:           # 求大于5的数
        return True
    return False
def fn(func,L):    # 参数L是被指定的列表
    new_lst = []
    for n in L:
        if func(n):
            new_lst.append(n)
    return new_lst
print(fn(fn2,lst))   # 输出结果为：[2, 4, 6, 8, 10]
print(fn(fn3,lst))   # 输出结果为：[6, 7, 8, 9, 10]

1.2 匿名函数

• filter()一个高阶函数，需要将别的函数作为参数来传递
• 可以将可迭代对象进行过滤
• 返回值是可迭代对象

lst = [1,2,3,4,5,6,7,8,9,10]
def fn4(i):
    if i % 3 ==0:
        return True
    return False
print(filter(fn4,lst))        # 输出结果为： <filter object at 0x000001E19A1989B0>
print(list(filter(fn4,lst)))   # 输出结果为：[3, 6, 9]

• 匿名函数，lambda表达式
• lambda表达式专门用来创建一些简单的函数（单一函数），也是函数的另一种创建方式
• 语法：lambda 参数列表：返回值

def fn5(a,b):
    return a + b
print(fn5(1,2))           # 输出结果为：3
print((lambda a,b:a + b)(10,50))  # 输出结果为：60

• 将匿名函数赋值给一个变量

fn6 = (lambda a,b : a + b)(6,7)
print(fn6)    # 输出结果为：13

fn6 = lambda a,b : a + b
print(fn6(5,6))      # 输出结果为：11

• 匿名函数最大的好处就是它只会用一次，用完就会从内存中消失

lst = [1,2,3,4,5,6,7,8,9,10]
r = filter(lambda i:i % 3 == 0,lst)
print(list(r))       # 输出结果为：[3, 6, 9]

2、闭包

• 高阶函数第二种，将函数作为参数返回，这种高阶函数称之为闭包
• 闭包的好处
  • 通过闭包可以创建⼀些只有当前函数能访问的变量
  • 可以将⼀些私有数据藏到闭包中

def make_fn():
    nums = []
    def fn1(n):
        nums.append(n)
        return sum(nums)/len(nums)
    return fn1
mf = make_fn()
print(mf(10))    # 输出结果为：10.0
nums = []       # 对内部列表无影响
print(mf(20))     # 输出结果为：15.0

• 形成闭包的条件
  • 函数嵌套
  • 将内部函数作为返回值返回 （高阶函数的必要条件之一）
  • 内部函数必须要使⽤到外部函数的变量

3、装饰器的引入

• 我们可以直接通过修改函数中的代码来完成需求，但是会产⽣以下⼀些问题
  • 如果修改的函数多，修改起来会⽐较麻烦
  • 不⽅便后期的维护
  • 这样做会违反开闭原则(ocp) ，
    • 程序的设计，要求开放对程序的扩展，要关闭对程序的修改
• 对函数进行扩展，可以通过装饰器来解决

4、装饰器的使用

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

def fn():
    print('我是fn函数')
def start_end():
    def new_func():
        print('函数开始执行')
        fn()
        print('函数执行结束')
    return new_func
f = start_end()
f()           # 输出结果为：函数开始执行  我是fn函数  函数执行结束

def fn():
    print('我是fn函数')
def start_end(old):
    def new_func():
        print('函数开始执行')
        old()
        print('函数执行结束')
    return new_func
f = start_end(fn)
f()          # 输出结果为：函数开始执行  我是fn函数  函数执行结束

def fn():
    print('我是fn函数')
def start_end(old):
    # 内部创建了一个函数
    def new_function(*args,**kwargs):
        print('函数开始执行')
        r = old(*args,**kwargs)
        print('函数执行结束')
        # 返回函数的执行结果
        return r
    # 返回新的函数
    return new_function
f = start_end(fn)
r = f()
print(r)                  # 输出结果为：函数开始执行  我是fn函数  函数执行结束  None

def add(a,b):
    r = a + b
    return r
def start_end(old):
    # 内部创建了一个函数
    def new_function(*args,**kwargs):
        print('函数开始执行')
        r = old(*args,**kwargs)
        print('函数执行结束')
        # 返回函数的执行结果
        return r
    # 返回新的函数
    return new_function
f2 = start_end(add)
r = f2(13,46)
print(r)     # 输出结果为：函数开始执行  函数执行结束  59

• 像类似于start_end(old)这种函数我们就称之为装饰器
• 通过装饰器可以在不修改原来的函数的情况下对函数进行扩展
• 在开发中，我们都是通过装饰器来扩展函数的功能的

def start_end(old):
    # 内部创建了一个函数
    def new_function(*args,**kwargs):
        print('函数开始执行')
        r = old(*args,**kwargs)
        print('函数执行结束')
        # 返回函数的执行结果
        return r
    # 返回新的函数
    return new_function
@start_end
def speak():
    print('同志们辛苦了！！！！')
speak()   # 输出结果为：函数开始执行  同志们辛苦了！！！！  函数执行结束