9月7日课后笔记

9月7日课后笔记

高阶函数

高阶函数有2个特点，符合任意的一个特点这个函数就是个高阶函数
1、接收一个或多个函数作为参数
2、将函数作为返回值返回的也个高阶函数

lst = [1,2,3,4,5,6,7,8,9,10]
a = []
# 定义一个函数
# 可以指定一个列表中的所有偶数，保存到一个新列表
def fn(l):
    for i in l:
        if i % 2 == 0:
            a.append(i)
    return a
b = fn(lst)
print(b)

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/71.py"
[2, 4, 6, 8, 10]

# 当我们使用一个函数作为参数的时候，实际上是将指定的代码传递到了目标函数
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 > 5:
        return True
    return False
def fn3(i):
    if i % 3 == 0:
        return True
    return False
def fn(func,l):
    new_lst = []
    for n in l:
        if func(n):
            new_lst.append(n)
    return new_lst
print(fn(fn1,lst))
print(fn(fn2,lst))
print(fn(fn3,lst))

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/72.py"
[2, 4, 6, 8, 10]
[6, 7, 8, 9, 10]
[3, 6, 9]

匿名函数

# filter()就是一个高阶函数，它需要将别的函数作为参数来传递
# 可以将我们的可迭代对象进行一个过滤
lst = [1,2,3,4,5,6,7,8,9]
def fn4(i):
    if i % 3 == 0:
        return True
    return False
print(list(filter(fn4,lst)))

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/73.py"
[3, 6, 9]

# 匿名函数 lambda表达式
# lambda函数表达式是专门用来创建一些简单的函数，它也是函数的另一种创建方式
# 语法：lambda 参数列表：返回值
print((lambda a,b:a+b)(2,5))
# 将匿名函数赋值给一个变量
r = (lambda a,b,c:a+b-c)
print(r(11,6,2))
print(type(r))
# 匿名函数最大的好处是它只会用一次，用完之后它就会消失
lst = [1,2,3,4,5,6,7,8,9]
a = filter(lambda i:i % 3 == 0,lst)
print(list(a))

闭包

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

def make_fn():
    nums = []
    def fn1(n):
        nums.append(n)
        return sum(nums)/len(nums)
    return fn1
mf = make_fn()
print(mf(10))
nums = []
print(mf(20))
# 在闭包函数中，nums列表跟函数外的nums列表没有关系，确保了函数内nums变量的私有性

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/76.py"
10.0
15.0

装饰器的引入

def add(a,b):
    # 求2个数的和
    # print('函数开始执行')
    r = a + b
    # print('函数执行结束')
    return r
def mul(a,b):
    # 求2个数的乘积
    return a * b
# r = add(1,2)
# print(r)
# 我们可以直接通过修改函数的方式来完成这个需求，但是会产生一些问题
# 1. 如果要修改的函数过多，修改起来会非常麻烦
# 2. 不方便后期维护
# 3. 这样做会违反ocp原则(开闭原则) 要求开放对程序的扩展，要求关闭对程序的修改
# 我希望扩展fn函数，但是要求不修改原函数的情况下对它进行扩展
def fn():
    print('我是fn函数')
# 定义一个新的函数 就是对原函数进行的扩展
def fn2():
    print('函数开始执行')
    fn()
    print('函数执行结束')
# fn2()
def new_add(a,b):
    print('函数开始执行')
    r = add(a,b)
    print('函数执行结束')
    return r
r = new_add(1,2)
print(r)

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/79.py"
函数开始执行
函数执行结束
3

装饰器的使用

def fn():
    print('我是fn函数')
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
# f = start_end(fn)
# # f2 = start_end()
# # r = f(1,3)
# r = f()
# print(r)
# # print(f)
# # print(f2)

# f = start_end(fn)
# r = f()
# print(r)
# f2 = start_end(add)
# r = f2(13,46)
# print(r)
# 像类似于start_end(old)这种函数我们就称之为装饰器
# 通过装饰器可以在不修改原来的函数的情况下对函数进行扩展
# 在开发中，我们都是通过装饰器来扩展函数的功能的
@start_end
# @property
def speak():
    print('同学们辛苦了！！！！')
speak()

"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/80.py"
函数开始执行
同学们辛苦了！！！！
函数执行结束