study-tenth-func-3

1.高阶函数

特点：接收一个或多个函数作为参数，将函数作为返回值。

将指定列表中的偶数，保存到一个新的列表中返回。
lst = [1,2,3,4,5,6,7,8,9,10]


# 定义一个函数用来检测任意数的偶数
def fn2(i):
    if i % 2 == 0:
        return True


# 定义一个函数用来检测大于5的数
def fn3(i):
    if i > 5:
        return True
    return False

def fn4(i):
    if i % 3 == 0:
        return True
    return False

def fn(f,lst):



    # 参数lst 要进行筛选的列表

    # 创建一个新的列表
    new_lst = []

    # 对要筛选的列表进行遍历
    for n in lst:

        # 判断n的奇偶
        if f(n):

            new_lst.append(n)

    # 返回新的列表
    return new_lst

print(fn(fn4,lst))

1.2 匿名函数:lambda函数表达式

filter() 过滤器
参数 ：1 函数 2 需要过滤的序列(可迭代的) 返回值 过滤后的新的序列（可迭代的结构）

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


def f(i):
    if i % 3 == 0:
        return True
    return False
  print(fiflter(f,lst))
  输出结果：<filter object at 0x0000027C32CB0A58>
  print(list(filter(f,lst)))
  输出结果:[3,6,9]
  
def f(i):
    return i % 3 == 0
r = filter(lambda i: i % 3 == 0, lst)

print(list(r))
输出结果:[3,6,9]

匿名函数 lambda函数表达式
lambda函数表达式就是专门用来创建一些简单的函数
语法：lambda 参数列表 ： 返回值

fn = (lambda a, b: a + b)
print(fn(5,6))

2.闭包

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

1. 闭包可以创建一些只有当前函数才能访问的变量

def fn():

    a = 10
    # 在函数内部定义一个函数
    def fn2():
        print('这是fn2',a)
    # 将内部函数fn2作为返回值返回
    return fn2

# print(fn()) <function fn.<locals>.fn2 at 0x0000022FD3FC2D90>
# r = fn()    这是fn2()  10
# r()
# print(a)	name 'a' is not defined,封闭状态，里面可以看得到外面，外面看不到里边

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

• 形成闭包的条件

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

3.装饰器的引入

• 我们可以直接通过修改函数中的代码来完成需求，但是会产生以下一些问题

1. 若修改的函数为多数，修改起来会比较麻烦
2. 不方便后期的维护
3. 这样做会违反开闭原则(ocp)
   程序的设计，要求开发对程序的扩展，要关闭对程序的修改。

4.装饰器的使用

• 定义一个函数来对其他的函数进行扩展，是其他的函数可以在执行前打印开始执行，执行后打印执行结束

def fn():
    # 参数old 要扩展的函数对象
    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(add)
# r = f(123,456)
# print(r)
//start_end(old)这一类函数就称之为装饰器

@start_end
def speak():
    print('！！！！')


@start_end
def listen():
    print('。。。')


speak()
listen()

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