Python Diary - Day 10 函数下 闭包 装饰器

目录

一、函数下

1. 高阶函数

1.1 filter()函数

2.匿名函数

3. 闭包

4. 装饰器的引入

5. 装饰器的使用

二、小练习

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

---

一、函数下

1. 高阶函数

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

# 接收一个或者多个函数对象作为参数
# 将函数作为返回值

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

def fun2(n):
    if n % 2 == 0:
        return True

def fun1(fn):
    list2 = []
    for i in list1:
        if fn(i):
            list2.append(i)
    return list2

print(fun1(fun2))

# 运行结果：
[2, 4, 6, 8, 10]

1.1 filter()函数

• filter()函数 过滤 两个参数
  • 1. 传递一个函数对象
  • 2. 传递一个需要过滤的序列

# filter()函数 过滤 两个参数
# 1. 传递一个函数对象
# 2. 传递一个需要过滤的序列

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


def fun2(n):
    if n % 2 == 0:
        return True


print(list(filter(fun2, list1))) # filter函数返回的是filter对象
                                 # 需要进行强制转换才会得到想要的输出结果

# 运行结果：
[2, 4, 6, 8, 10]

2.匿名函数

• 匿名函数：就是没有名字的函数，不指定函数的名字
• 又称为lambda函数，语法：(lambda 参数:表达式)(传参)

res1 = lambda a, b: a + b
print(res1(1, 2))

res2 = (lambda a, b: a + b)(1,2)
print(res2)

# 运行结果：
3
3

• lambda函数和filter()函数配合使用

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
res = lambda i : i % 2 == 0
print(list(filter(res,list1)))

# 运行结果：
[2, 4, 6, 8, 10]

3. 闭包

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

# 行成闭包的条件
# 1. 函数嵌套
# 2. 将内部函数作为返回值返回  返回的是函数对象
# 3. 内部函数必须要使用到外部函数的变量

# 闭包的作用：保存外部函数的变量不被销毁
def fun_out(num1):
    # 定义一个内部函数
    def fun_inner(num2):
        # 内部函数用到了外部函数的变量或参数(num1)
        res = num1 + num2
        print(res)

    print(id(num1))
    return fun_inner

f = fun_out(1)
f(2)
f(3)

# 运行结果：
1456565264
3
4

def fun_out(num1):
    # 定义一个内部函数
    def fun_inner(num2):
        # 内部函数用到了外部函数的变量或参数(num1)
        num1 = 2
        res = num1 + num2
        print(f'res = {res}')
    print(f'num1 = {num1}')
    fun_inner(2)
    print(f'num1 = {num1}')
    return fun_inner

f = fun_out(1)
f(2)
f(3)

# 运行结果：
num1 = 1
res = 4
num1 = 1
res = 4
res = 5

# 修改外部变量
def fun_out(num1):
    # 定义一个内部函数
    def fun_inner(num2):
        # 内部函数用到了外部函数的变量或参数(num1)
        nonlocal num1 # 告诉解释器，此处用的是外部的变量num1
        num1 = 2
        res = num1 + num2
        print(f'res = {res}')
    print(f'num1 = {num1}')
    fun_inner(2)
    print(f'num1 = {num1}')
    return fun_inner

f = fun_out(1)
f(2)
f(3)

# 运行结果：
num1 = 1
res = 4
num1 = 2
res = 4
res = 5

4. 装饰器的引入

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

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

# fun()是做装饰的,而并不是装饰器
def fun(fn, *args, **kwargs):
    print('函数开始执行')
    res = fn(*args, **kwargs)
    print('函数执行结束')
    return res

print(fun(add, 1, 2))

# 运行结果：
函数开始执行
函数执行结束
3

# 装饰器是一个特殊的闭包
# 符合闭包的三大条件
def fun():
    print(111)

# 装饰器
def fun_out(fn):
    def fun_inner():
        print('函数开始执行')
        fn()
        print('函数执行结束')

    return fun_inner

f = fun_out(fun)
f()

# 运行结果：
函数开始执行
111
函数执行结束

5. 装饰器的使用

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

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

# 装饰器
def fun_out(fn):
    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        r= fn(*args, **kwargs)
        print('函数执行结束')
        return r

    return fun_inner

f = fun_out(add)
res = f(1, 2)
print(res)

# 运行结果：
函数开始执行
函数执行结束
3

def fun_out(fn):
    def fun_inner(*args, **kwargs):
        print('函数开始执行')
        r= fn(*args, **kwargs)
        print('函数执行结束')
        return r

    return fun_inner

@fun_out  # 装饰器语法糖的写法
# 语法糖： @fun_out 等价于 fun_out(fn)
def add(a, b):
    return a + b

res = add(1, 2)
print(res)

@fun_out
def fun():
    print(111)
fun()

# 运行结果：
函数开始执行
函数执行结束
3
函数开始执行
111
函数执行结束

二、小练习

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

• time模块

import time

def exetime(fn):
    def fun_inner(*args, **kwargs):
        local_time = time.time()
        fn(*args, **kwargs)
        print(f'{fn.__name__}函数执行,花费了 %.2f 秒' % (time.time()-local_time))

    return fun_inner


@exetime
def isLeapYear():
    year=int(input('请输入年份：'))
    if year%400==0 or year%4==0 and year%100!=0:
        print(f'{year}年是闰年')
    else:
        print(f'{year}年不是闰年')

isLeapYear()

# 运行结果：
请输入年份：2016
2016年是闰年
isLeapYear函数执行,花费了 1.82 秒