python中decorator-装饰器的用法

装饰器的定义

“”"
装饰器：
把一个函数当作参数，返回一个替代版的函数
本质上就是一个返回函数的函数

“在不改变原函数的基础上，给函数增加功能”
“”"
在企业中，别人定义好的函数我们一般是不能改动的，那么如果我们想在这个函数的基础上进行一些改动，装饰器就是一个很好的工具：

---

比如我们定义一个函数，他的功能是打印出hello world

def fun():
    print('hello world')

如果我们想让在打印helloworld之前打印别的东西，且不改变原函数，我们可以：
#一

这样的话如果次数太多会变的麻烦
#二：

def fun():
    print('hello world')
# print('linux to linux')
# fun()

def fun1():
    print('linux to linux')
    fun()
fun1()

这样的话函数名变成了fun1，调用方式改变，体现不出原函数。
#三：

def f1():
    print('hello world')
#定义装饰器
def decorator(fun):
    def wrapper():
        print('linux to linux')
        fun()
    return wrapper         这里不加括号，加上括号代表括号的运行结果，不加代表函数本身。

f = decorator(f1)           #把f1这个函数传进去，用f调用 
f()

这样函数名也变了，也有些体现不出原函数。

#四：
python中的语法糖是专门调用装饰器的

放置于函数的上方，以@开头，加上定义的装饰器函数，就可以直接调用装饰器的函数，先运行装饰器函数，在运行已经定义的函数。

def decorator(fun):
    def wrapper():
        print('linux to linux')
        fun()
    return wrapper
@decorator         #装饰器      
def f1():
    print('hello world')

f1()

---

练习：
已知函数：

def f1(func_name):
print('This is a function ’ + func_name)

要在打印的字符串前打印时间，要求用装饰器：
1，

import time

def decorator(func):
    def wrapper(*args):               # *args 表示可以接收多个参数
        print(time.time())            # 加的打印时间功能
        func(*args)
    return wrapper

@decorator
def f1(func_name):
    print('This is a function ' + func_name)
f1 ('test')

运行，

2，是否可以接收多个参数：

import time

def decorator(func):
    def wrapper(*args):
        print(time.time())
        func(*args)
    return wrapper

@decorator
def f2(func_name1,func_name2):
    print('This is a function ' + func_name1)
    print('This is a function ' + func_name2)
f2 ('test1','test2')

可以接受多个参数。

3，关键字参数

import time

def decorator(func):
    def wrapper(*args,**kwargs):         **kwargs代表接收关键字参数
        print(time.time())
        func(*args,**kwargs)
    return wrapper              #这是标准的装饰器写法

@decorator
def f3(func_name1,func_name2,**kwargs):
    print('This is a function ' + func_name1)
    print('This is a function ' + func_name2)
    print(kwargs)

f3('test1','test2',a=1,b=2,c='hello')

---

练习二：

“”"
用 装饰器实现一个函数计时器
“”"

函数计时器就是在函数前后加上时间，然后两个在一相减。

import time

def timetest(fun):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        fun(*args,**kwargs)
        end_time = time.time()
        print('the running time is: %.6f' %(end_time - start_time))
    return wrapper

@timetest
def fun_list(n):
    return [2 * i for i in range(n)]

#@timetest
#def fun_map(n):
#    return list(map(lambda x:x*2 ,range(n)))

print(fun_list(10000))           单纯执行函数只是执行函数里面的内容，所以要print打印出来

但是这样的执行结果是这样的：

因为在执行装饰器函数的时候，会先进入装饰器函数中，fun(*args,**kwargs) 这个代码只是运行了对应的 fun_list() 函数的内容，缺少了对其运行结果的处理，所以应定义返回值，wrapper 中并没有返回值，返回值对应的是执行结果，只有定义了返回值，才可以看到执行结果。

import time

def timetest(fun):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res = fun(*args,**kwargs)       #这一行
        end_time = time.time()
        print('the running time is: %.6f' %(end_time - start_time))
        return res						#这一行
    return wrapper

@timetest
def fun_list(n):
    return [2 * i for i in range(n)]

#@timetest
#def fun_map(n):
#    return list(map(lambda x:x*2 ,range(n)))

print(fun_list(10000))

执行：

functools工具包中的wraps装饰器作用及用法

在他人使用函数式，为了使使用者易于读懂，会使用wraps工具包保留原函数名和帮助信息文档，通常卸载wrapper函数上方，用法如下：

import time
import functools

def timetest(fun):
    """This is a decorator fun"""
    @functools.wraps(fun)         不加这条命令会打印出 wrapper 的帮助文档和函数名
    def wrapper(*args,**kwargs):
        """This is a wrapper function"""
        start_time = time.time()
        res = fun(*args,**kwargs)
        end_time = time.time()
        print('the running time is: %.6f' %(end_time - start_time))
        return res
    return wrapper

@timetest

def fun_list(n):
    """This is the fun_list function"""          帮助文档
    return [2 * i for i in range(n)]

# print(fun_list(10000))
print(fun_list.__doc__)
print(fun_list.__name__)

这时使用 print(fun_list.doc) 命令就可以看见原函数的帮助文档
使用 print(fun_list.name) 命令就可以看见原函数名

---

练习二：

创建装饰器， 要求如下：

1. 创建add_log装饰器， 被装饰的函数打印日志信息；
2. 日志格式为: [字符串时间] 函数名: xxx， 运行时间：xxx, 运行返回 值结果:xxx

import time
import functools

def add_log(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res = fun(*args,**kwargs)
        end_time = time.time()
        print('[%s] 函数名: %s, 运行时间: %.6f,运行返回值结果: %d' %(time.ctime(),fun.__name__,end_time - start_time,res) )
        return res
    return wrapper
    
@add_log
def add(x,y):
    time.sleep(1)
    return x+y

add(1,10)

执行结果：

---

##判断参数是不是一个类型：

用 isinstance 判断一个参数是不是后面跟的数据类型。

练习三：带参数的装饰器

编写装饰器required_types, 条件如下:

 1). 当装饰器为 @required_types(int,float) 确保函数接收到的每一>个参数都是int或者float类型;
 
 2). 当装饰器为 @required_types(list) 确保函数接收到的每一个参数 都是list类型;
 
 3). 当装饰器为 @required_types(str,int) 确保函数接收到的每一个>参数都是str或者int类型;
 
 4). 如果参数不满足条件， 打印 TypeError:参数必须为xxxx类型

import functools

def required_types(*kind):         #这个函数用来接收数据类型
    def required(fun):             #这个函数用来导入函数
        @functools.wraps(fun)
        def wrapper(*args,**kwargs):           #装饰器函数
            for i in args:
                if not isinstance(i,kind):
                    print('TypeError: 参数必须为%s,%s类型' %kind)
                    exit()
            else:
                res = fun(*args,**kwargs)
                return res
        return wrapper
    return required

@required_types(float,float)      #括号内的参数为数据类型
def add(a,b):
    return a + b

print(add(1.2,2.1))

两个数据都是浮点型时执行结果正常。

数据类型不符合装饰器参数时报错

练习四：多个装饰器

#装饰器1
def decorator_a(fun):
    def inner_a(*args,**kwargs):
        print('This is inner_a')
        res = fun(*args,**kwargs)
        return res
    return inner_a

#装饰器2
def decorator_b(fun):
    def inner_b(*args,**kwargs):
        print('This is inner_b')
        b = fun(*args,**kwargs)
        return b
    return inner_b

#都放在函数上面，会按顺序执行附加功能
@decorator_b
@decorator_a
def f(x):
    print('This is f')
    return x*2

print(f(1))

可以看出先执行了装饰器 b ，因为它放在上面。