<Python基础>装饰器的基本原理

1.装饰器

　　所谓装饰器一般是对已经使用(上线)的函数增加功能.

　　但是因为一般的大公司的严格按照开放封闭原则(对扩展是开放的,对修改是封闭的),不会让你修改原本的函数.

　　装饰器就是在不改变原本的函数且不改变原本函数的调用方式上,为原本的函数增加功能的东西.

　　所以需求就是:

　　1.不改变原函数

　　2.不改变原函数的调用方式

　　3.增加函数的功能

1.1最基本的装饰器

　　假设存在这样的原函数

import time
def func():
    time.sleep(0.01)
    print('func is running!')

　　很简单的一个函数,我们现在要为这个原函数增加一个计算函数运行时间的功能.

　　我们知道计算函数运行时间的函数可以这么写:

def time_func():
    start = time.time() #记录运行前时间
    func()              #调用原函数
    end = time.time() #记录运行结束时间
    print(end - start)

time_func()

　　运行结果:

func is running!
0.01015472412109375

　　这样虽然可以算出函数的运行时间,但是对原函数的调用就完全变了,为了让调用不变,我们可以将装饰器函数写成这样:

def time_func(f):
    def inner():
        start = time.time() #记录运行前时间
        f()              #调用原函数
        end = time.time() #记录运行结束时间
        print(end - start)
    return inner    #返回inner的地址

print(func)         #func函数的地址
func = time_func(func)  #将func函数的内存地址发给time_func函数
print(func)     #inner函数的地址
func()

　　运行结果:　

<function func at 0x0000023371712E18>
<function time_func.<locals>.inner at 0x00000233735867B8>
func is running!
0.010173320770263672

　　可以看到这个装饰器函数实现了通过原函数的调用方式---func()---实现了计算函数的运行时间功能的增加.实现的最基本的装饰器功能.

　　分析一下实现过程:

　　1.将func函数的内存地址作为参数传给time_func函数,使inner中的f()就相当于func()调用原函数

　　2.time_func将inner函数的地址赋值给变量func,让第12行的func()等价于inner()

　　使得表面上是:

　　　　　　func()调用原函数

　　实际上是:

　　　　　　func()等价于inner()

　　　　　　inner调用f()

　　　　　　func作为参数传给time_func函数,即f()等价于func()

1.2  有返回值的装饰器

　　最开始发原函数太简单了,我们给他增加返回值:

import time
def func():
    time.sleep(0.01)
    print('func is running!')
    return 'Hello World!'

　　通过分析,我们知道前面的func()其实是inner(),而inner函数本身没有返回值,我们需要在inner()中增加接受原函数的返回值并返回的功能,可以写作:

def time_func(f):
    def inner():
        start = time.time() #记录运行前时间
        ret = f()              #ret接受原函数的返回值原函数  ----增加的行
        end = time.time() #记录运行结束时间
        print(end - start)
        return ret  #返回原函数的返回值  ----增加的行
    return inner    #返回inner的地址

func = time_func(func) 
print(func())

　　运行结果:

func is running!
0.01049661636352539
Hello World!

1.3 有参数的装饰器

　　有的返回值,还缺什么才比较像基本的函数?    参数

　　先来简单一点的,有限个参数的,原函数写作:

import time
def func(a,b):
    time.sleep(0.01)
    print('func is running!',a,b)
    return 'Hello World!'

　　有参数和返回值不是一样么,在inner函数后面加上参数不就得了,装饰器可以写做:

def time_func(f):
    def inner(a,b): #增加参数　　 　　　　　　　　　　　　　　--增加的行
        start = time.time() #记录运行前时间
        ret = f(a,b)              #将inner函数接到的参数传给原函数  --增加的行
        end = time.time() #记录运行结束时间
        print(end - start)
        return ret  #返回原函数的返回值
    return inner    #返回inner的地址

func = time_func(func) 
print(func('haha','heihei'))   #传入haha和heihei

　　运行结果:

func is running! haha heihei
0.010972023010253906
Hello World!

　　成功了!

　　实际中,原函数的参数可能有很多种,数量也不可能固定不变,不可能原函数的参数一变,你就去改装饰器函数,这样太麻烦

　　为了解决参数的问题,我们提出王炸策略

　　*args   ------动态参数,可以接受任意数量的位置参数

　　**kwargs ----动态参数,可以接受任意数量的关键字参数

　　这种策略在python内置函数中多有用到,比如len函数:

def len(*args, **kwargs): # real signature unknown
    """ Return the number of items in a container. """
    pass

　　它能接受一切数量的参数,无论是位置参数还是关键字参数,仿照这个,我们可以写出接受任意参数的装饰器函数

　　原函数:

import time
def func(*args, **kwargs):
    time.sleep(0.01)
    print('func is running!',*args, **kwargs)
    return 'Hello World!'

　　装饰器函数:

def time_func(f):
    def inner(*args, **kwargs): #增加参数　　　　----修改部分
        start = time.time() #记录运行前时间
        ret = f(*args, **kwargs)              #将inner函数接到的参数传给原函数-----修改部分
        end = time.time() #记录运行结束时间
        print(end - start)
        return ret  #返回原函数的返回值
    return inner    #返回inner的地址

# print(func)         #func函数的地址
func = time_func(func)  #将func函数的内存地址发给time_func函数
# print(func)     #inner函数的地址
print(func('haha','heihei',1,2,3,4,5,6,3,2,1))

　　运行结果:

func is running! haha heihei 1 2 3 4 5 6 3 2 1
0.010983467102050781
Hello World!

1.4  装饰器的固定模式

　　前面以求运行时间为例,将其进行推广就可以得到装饰器的固定模式:

def wrapper(f):    #装饰器函数，f是被装饰的函数
    def inner(*args,**kwargs):
        '''在被装饰函数之前要做的事'''
        ret = f(*args,**kwargs)    #被装饰的函数
        '''在被装饰函数之后要做的事'''
        return ret
    return inner

func = wrapper(func)   #感觉有点多余

　　很明显发现第九行看起来有点多余,于是有了语法糖的概念

　　语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。----by百度百科

　　装饰器的语法糖就是在被装饰函数,也就是原函数的前面加@装饰器函数

　　像这样:

@wrapper
def func(*args, **kwargs):
    time.sleep(0.01)
    print('func is running!',*args, **kwargs)
    return 'Hello World!'

　　由于@wrapper 等价于func = wrapper(func)

　　而@wrapper要写在原函数上面,按照python解释器从上到下的工作规律,如果装饰器函数在原函数下面,@wrapper相当于没有意义,会报错,所以装饰器函数必须在原函数之前,整体写做这样:

import time

def wrapper(f):    #装饰器函数，f是被装饰的函数
    def inner(*args,**kwargs):
        '''在被装饰函数之前要做的事'''
        ret = f(*args,**kwargs)    #被装饰的函数
        '''在被装饰函数之后要做的事'''
        return ret
    return inner

@wrapper
def func(*args, **kwargs):
    time.sleep(0.01)
    print('func is running!',*args, **kwargs)
    return 'Hello World!'
print(func('haha','heihei',1,2,3,4,5,6,3,2,1))

　　运行结果:

func is running! haha heihei 1 2 3 4 5 6 3 2 1
Hello World!