day04-函数，装饰器初成

面试的时候，经常被问过装饰器，所以掌握好装饰器非常重要。
一.装饰器形成的过程：1.最简单的装饰器。2.被装饰的函数有返回值。3.被装饰的函数有一个参数。4.被装饰的函数有多个位置参数。5.被装饰的函数有多个位置参数和关键字参数。
二.装饰器的作用：不修改被装饰的函数的代码和调用方式，增加新的功能。
三.原则：开放封闭原则。
四.语法糖：@wrapper
五.装饰器的固定模式。


一.装饰器形成的过程：1.最简单的装饰器。注意：下面代码没修改被装饰的函数的代码，但是调用使用了timmer(test)而不是test(),改变了调用方式，会导致
                                     以前调用该函数的程序发生错误(如果以前有人使用过你写的函数)。
使用 时间函数 计算 代码 运行的时间
import time
def timmer(t):                                                  #timmer(t)是时间装饰器
    start = time.time()     #开始：函数开始运行的时间
    time.sleep(0.01)        #让函数睡眠0.01秒，否则打印的结果是0.0。
    t()                     #过程：函数运算的过程。t()表示调用被装饰的函数。
    end = time.time()       #结束：函数结束运行的时间
    print(end-start)        #打印出运算的过程需要多少时间
def test():
    print('今天必须非常努力，我要寻找热爱学习热爱工作的自己，我会为自己的努力而感到快乐幸福和满足')
timmer(test)        #把需要计算运行时间的函数对象(或者说是地址)传给时间函数timmer


1.在不准修改test函数的情况下，装饰器发挥非常重要的作用：不修改test函数的代码，那么调用test函数的方式也不能修改，但是想在函数前后增加功能。
2.下面例子，test()这种调用函数的方式没有改变，但是给test函数增加了计算运行时间的功能。
3.开放封闭原则：对拓展(增加功能)是开放的，但是对修改被装饰的函数是封闭的。

一.装饰器形成的过程：1.最简单的装饰器：不修改被装饰的函数的代码和调用方式，使用了内部函数和闭包。
import time
def timmer(f):              #装饰器函数
    def inner():
        start = time.time()
        time.sleep(0.01)
        f()                 #被装饰的函数
        end = time.time()
        print(end-start)
    return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
test = timmer(test)
def test():
    print('今天必须非常努力，我要寻找热爱学习热爱工作的自己，我会为自己的努力而感到快乐和幸福和满足')
test()                 #test()=inner()



#一.装饰器形成的过程：2.被装饰的函数有返回值。
import time
def timmer(f):              #装饰器函数
    def inner():
        start = time.time()
        time.sleep(0.01)
        n = f()                 #被装饰的函数
        end = time.time()
        print(end-start)
        return n
    return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
test = timmer(test)
def test():                  #被装饰的函数
    print('今天必须非常努力，我要寻找热爱学习热爱工作的自己，我会为自己的努力而感到快乐和幸福和满足')
    return 10000000
print(test())           #test()=inner()


#一.装饰器形成的过程：3.被装饰的函数有一个参数。
import time
def timmer(f):              #装饰器函数
    def inner(a):
        start = time.time()
        time.sleep(0.01)
        n = f(a)                 #被装饰的函数
        end = time.time()
        print(end-start)
        return n
    return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
test = timmer(test)
def test(a):               #被装饰的函数
    print('加油',a)
    return 10000000
print(test(10000000))           #test(a)=inner(a)


一.装饰器形成的过程：4.被装饰的函数有多个位置参数。
import time
def timmer(f):              #装饰器函数
    def inner(*args):
        start = time.time()
        time.sleep(0.01)
        n = f(*args)                 #被装饰的函数
        end = time.time()
        print(end-start)
        return n
    return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
test = timmer(test)
def test(*args):          #被装饰的函数
    print('加油',args)
    return 10000000
print(test(1,2,3))           #test(*args)=inner(*args)


#一.装饰器形成的过程：5.被装饰的函数有多个位置参数和关键字参数。
import time
def timmer(f):              #装饰器函数
    def inner(*args,**kwargs):
        start = time.time()
        time.sleep(0.01)
        n = f(*args,**kwargs)                 #被装饰的函数
        end = time.time()
        print(end-start)
        return n
    return inner          #test=timmer(test)=inner,返回inner的id给timmer(test)
test = timmer(test)
def test(*args,**kwargs):          #被装饰的函数
    print('加油',args,kwargs)
    return 10000000
print(test(1,2,3,t=8000000,m=10000000))           #test(*args,**kwargs)=inner(*args,**kwargs)


四.语法糖：@wrapper
import time
def timmer(f):
    def inner():
        start = time.time()
        time.sleep(0.01)
        n = f()
        end = time.time()
        print(end - start)
　　　　　　　return n 
    return inner
@timmer            #语法糖@timmer相当于 func=timmer(func)  没有语法糖或func=timmer(func)，装饰器就无法起作用。
def func():
    print('今天继续加油')
func()



五.装饰器的固定模式。wrapper是装饰的意思。
def wrapper(f):
    def inner(*args,**kwargs):
        '''在被装饰的函数前面增加功能'''
        ret = f(*args,**kwargs)
        '''在被装饰的函数后面增加功能'''
        return ret
    return inner                            #上面五句话是装饰器的固定模式。
@wrapper
def func(*args,**kwargs):
    return args,kwargs
print(func(1,2,3,m=10000000))

六.装饰器的执行过程：
1. def wrapper(f):
  4. def inner(*args,**kwargs):
     7. '''在被装饰的函数前面增加功能'''
     8.  ret = f(*args,**kwargs)
     9.  '''在被装饰的函数后面增加功能'''
     10.  return ret               #返回func(1,2,3,m=10000000)的返回值，因为第6步使用了print，所以被装饰的函数的返回值就被打印出来。
  5. return inner               #返回inner给wrapper(func),那么inner=wrapper(func)=func
3. @wrapper                   #func=wrapper(func)传参
2. def func(*args,**kwargs):
    return args,kwargs
6. print(func(1,2,3,m=10000000))   #func=inner,相当于print(inner(1,2,3,m=10000000)),接着内部函数inner执行。
                                     调用func函数实际上是调用了装饰器的内部函数：inner函数。