python语法基础-函数-装饰器-长期维护

#########################################################

# 装饰器
# 装饰器非常重要，面试Python的公司必问，
# 原则：开放封闭原则

# 开放封闭原则，适用于对已经固定的额功能，和源码，这个原则是为了程序的稳定性，
# 开放就是对已经有的功能的拓展是开放的，
# 封闭就是对已经有的功能是不改动的，

###############    装饰器的初成和开放封闭原则    ##############

# 需求：计算程序执行的时间，

# 第一版：直接在函数的前后增加代码，

# 需求：计算程序执行的时间，
# 第一版：直接在函数的前后增加代码，
import time
def func():
    start = time.time()  # 这是获取当前的时间戳，#计算时间差使用
    time.sleep(1.01)
    print(123)
    end = time.time()
    print(end - start)  # 1.0140016078948975，这个时间差就是秒了，
func()

# 这种写法有明显的缺点，
# 1，这种不符合开放封闭原则
# 2，这种写法如果有100个函数，你都要加一遍这是不行的，太麻烦了，

# 第二版：写一个函数，然后把需要计算执行时间的函数作为参数传递进去，

# 第二版：写一个函数，然后把需要计算执行时间的函数作为参数传递进去，
def func():
    time.sleep(0.01)
    print(123)
def timer(f):
    start = time.time()
    f()
    end = time.time()
    print(end - start)
timer(func)  # 专门写了一个函数用来计算函数的执行时间，

# 第三版：闭包的写法

# 第三版：闭包的写法
def func():
    time.sleep(0.01)
    print(123)
def timer(f):  # 函数作为参数传递进去，就是外部函数的一个变量了，
    def inner():
        start = time.time()
        f()  # 这是内部函数引用外部函数的变量，构成一个闭包，
        end = time.time()
        print(end - start)
    return inner
# 这就是一个闭包，因为是函数的嵌套，并且函数内部调用函数外部的参数，
# 不修改函数的调用方式，还想要在函数的前后添加功能，
# timer就是一个装饰器，对函数有装饰作用，
func = timer(func)  # inner
func()  # inner()

# 所以使用装饰器是一个非常不错的方式在不改变程序内部的情况下，在程序的前后添加功能，

###############    最终的装饰器版本    ##############

# 最终的装饰器版本
# 解决两个问题，
# 1是被装饰函数有返回值
# 2是被装饰函数有参数

import time
def timer(f):
    def inner(*args, **kwargs):  # 这个参数就是为了能接收被装饰器函数的参数，
        # 为什么要把参数写到内层函数里面，就是因为，被装饰过的函数已经拿到了inner这个函数名了，下一步调用的是inner
        # 所以要给inner传递参数，
        start = time.time()
        ret = f(*args, **kwargs)
        end = time.time()
        print(end - start)
        return ret  # 这个地方要返回是因为被装饰函数可能会有返回值，
        # 这个返回值就是被装饰函数的返回值
    return inner

@timer  # func = timer(func)  # inner
def func(a):
    """函数"""
    time.sleep(0.01)
    print(123)
    print(a)
    return 123
# func = timer(func)  # inner
ret = func(1)  # inner()，这个地方已经是调用的inner了，所以一定要在inner中把被装饰函数的返回值返回回来，
print(func.__name__)  # 这个被装饰器装饰了之后会有问题，inner返回的是inner，而不是func
print(func.__doc__)  # 这是none
# print(ret)

装饰器的固定模式：

# 所有有一个装饰器的固定模式
from functools import wraps
def outer(func):  # 或者叫做wrapper，这就是装饰器的意思，一般会起一个和业务相关的名字，
    @wraps(func)  # 加上这一句，再去打印函数的name的时候，就不会是inner了，
    def inner(*args, **kwargs):  # 一般就是一个inner
        # 在被装饰函数之前写的东西
        ret = func(*args, **kwargs)
        # 在被装饰函数之后写的东西
        return ret
    return inner

@outer  # 这一句就是test=outer(test)
def test():
    """
    函数测试，
    :return:
    """
    print(123)

test()  # 这个地方就是inner()了，就是
print(test.__name__)  # 这个被装饰器装饰了之后会有问题，inner返回的是inner，而不是test，@wraps(func)就是解决这个问题，
print(test.__doc__)

注意点：

1，嵌套函数
2，内部引用外部变量
3，返回内部函数的名字
4，被装饰函数的参数
5，被装饰函数的返回值，
6，改变inner的名字，

###############    装饰器进阶--带参数的装饰器    ##############

"""

装饰器进阶
1，带参数的装饰器

场景：就是我写了一个计算代码执行时间的装饰器，然后给每一个函数加上了装饰器，
如果我想要去掉装饰器的时候，就需要一个一个的去掉了，我想要用的时候还需要再一个一个的加上，很麻烦，有什么好的办法？

解决方法：就是给装饰器加上一个参数，然后通过控制参数来判断是否开启装饰器，
参数就叫做flag，
这种代码实现就是使用三层装饰器，这样只需要控制flag就可以控制装饰器是否开启了，

"""

import time

flag = False
def timmer_out(flag):
    def timmer(func):
        def inner(*args,**kwargs):
            if flag:
                start = time.time()
                ret = func(*args,**kwargs)
                end = time.time()
                print(end-start)
                return ret
            else:
                ret = func(*args, **kwargs)
                return ret
        return inner
    return timmer

@timmer_out(flag)
def test1():
    time.sleep(1)
    print(123)

@timmer_out(flag)
def test2():
    time.sleep(1)
    print(123)

# @timmer：这一句还好理解就是func=timmer(func)
# @timmer_out(flag)：为了传递参数，我们可以再次在装饰器外部加一层，用来传递参数，
# 这一句要分开看了，第一步是timmer_out(flag)，然后返回了timmer，第二步才是@timmer，执行装饰器，

test1()
test2()

###############   装饰器进阶---多个装饰器装饰一个函数    ##############

"""
装饰器进阶：
2，多个装饰器装饰一个函数，
"""
def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner

def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner

@wrapper2
@wrapper1
def f():
    print('in f')

f()
"""
执行结果：
wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func
说明了几个问题：
1，多个装饰器是把函数之前的装饰代码都执行之后，然后才是执行被装饰函数，最后是函数之后的装饰代码
2，函数之前的执行顺序是谁在上面执行谁，这是从上到下，函数之后的执行顺序是谁在下面执行谁，这是从下往上，
就像是俄罗斯套娃，进的时候从外往里，出的时候从里往外，
"""

###############################################

############################################