Python_day11_高阶函数、匿名函数、闭包、装饰器、命名空间

高阶函数

• 概念：接手函数作为参数，或者将函数作为返回值返回的函数就是高阶函数
  通过例子衍生出高阶函数

# 定义一个函数，将偶数添加到新列表当中
lst = [1,2,3,4,5,6,7,8,9,10]
def fn(l):
    new_lst = []
    for i in l:
        if i % 2 == 0:
            new_lst.append(i)
    return new_lst
print(fn(lst))

# 定义一个函数，将奇数添加到新列表当中
lst = [1,2,3,4,5,6,7,8,9,10]
def fn(l):
    new_lst = []
    for i in l:
        if i % 2!= 0:
            new_lst.append(i)
    return new_lst
print(fn(lst))

# 定义一个函数，将大于5添加到新列表当中
lst = [1,2,3,4,5,6,7,8,9,10]
def fn(l):
    new_lst = []
    for i in l:
        if i > 5:
            new_lst.append(i)
    return new_lst
print(fn(lst))

引出高阶函数：

lst = [1,2,3,4,5,6,7,8,9,10]
def fn1(i):
    if i % 2 == 0:
        return True

def fn2(i):
    if i % 2 != 0:
        return True

def fn3(i):
    if i > 5:
        return True

def fn4(i):
    if i < 5:
        return True
def fn(func,l):
    new_lst = []
    for i in l:
        if func(i):
            new_lst.append(i)
    return new_lst
print(fn(fn4,lst))

• 高级函数有什么好处？
• 当我们使用一个函数作为参数的时候，实际是将指定的代码传递到目标函数

匿名函数

filter

• filter，（函数，对象）可以对列表进行一个过滤
• function函数对象
• interable 可迭代对象（序列）

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))

lambda

• lambda函数表达式：可以用来创建一些简单的函数，它是函数的另一种创建方式
• 语法：lambda 参数列表：返回值
• 例题：定义一个函数 实现2个数的和

def fn(a,b):
    return a + b
print(fn(1,2))

def fn(a,b):
    return a + b
print(lambda a,b:a+b) # <function <lambda> at 0x00000262CB7D1AE8>

def fn(a,b):
    return a + b
print((lambda a,b:a+b)(122,344)) # 466

def fn(a,b):
    return a + b
fn1 = lambda a,b:a+b
print(fn1(1,2)) # 3

闭包

• 将函数作为返回值返回的函数

def fn1():
    def fn2():
        print('我是fn2')
    return fn2
fn1()()
# r = fn1()
# r()

def make_fn():
    lst = []
    def fn1(n):
        lst.append(n)
        return sum(lst)/len(lst)
    return fn1
f = make_fn()
print(f(100))
print(f(50))
# 执行结果：
100.0
75.0

形成闭包的条件 ：
1、函数嵌套
2、将内部函数作为返回值返回
3、内部函数必须要使用到外部函数的变量

装饰器的引入

• 创建几个简单的功能函数

def add(a,b):
# 求任意两个数的和
	return a + b
r = add(12,36)
print(r)

def add(a,b):
    r = a + b
    return r
# n = add(10,2)
# print(n)
def fn():
    print('我是函数fn....')
def fn2():
    print('函数开始了....')
    fn()
    print('函数结束了....')
def new_add(a,b):
    print('函数开始了....')
    r = add(a,b)
    print('函数结束了....')
    return r
r = new_add(123,456)
print(r)

我们可以直接通过修改函数中的代码去完成这个需求，但是会产生一些问题
1 如果要修改的函数比较多，修改起来比较麻烦
2 不方便后期的维护
3 这种方式会违反开闭原则(ocp) 要求对开发程序的扩展，要求关闭程序的修改
直接目的为调用现有的函数实现优化功能

装饰器的使用

def fn():
    print('我是函数fn')
    return
def add(a,b):
    r = a+b
    return r
def start_end(old):
    def new_function(*a,**b):
        print('函数调取中...')
        print('函数开始了')

        print('函数计算中')
        result=old(*a,**b)
        print('函数结束了')

        return result
    return new_function
# r=start_end(add)
p=start_end(add)
print(p(1,2))
@start_end
def speak():
    print('同学们都辛苦了，加油加油')
speak()
#执行结果

> 函数调取中... 
> 函数开始了
> 函数计算中 
> 函数结束了 
>  3 
> 函数调取中...
> 函数开始了 
> 函数计算中 
> 同学们都辛苦了，加油加油 函数结束了

以上课堂示例，结果执行顺序不理解

命名空间

• locals()来获取当前作用域的命名空间 返回的是一个字典

a = 10

def fn():
    print('我是函数fn....')

# scope = locals()
# # print(scope)
# # print(a)
# # print(scope['a'])
# scope['c'] = 123 # 像命名空间中添加了key-value 就相当于在全局中创了一个变量
# print(c)
# print(scope)

def fn2():
    a = 456
    scope = locals()
    scope['c'] = 123
    print(c)
    print(scope)
fn2()