python学习28：装饰器

---

1. 装饰器

• 把一个函数当作参数传递给另一个函数 返回一个替代版的函数
• 本质上就是一个返回函数的函数
• 在不改变原函数的基础上 给函数增加功能

def say_hello(name):
    return f"Hello {name}"


def be_some(name):
    return f"Your {name}"

def greet_bob(func):
    return func("Bob")

print(greet_bob(say_hello))  #在greet_bob函数中调用say_hello函数
print(greet_bob(be_some))  #在greet_bob函数中调用be_some函数

2. @修饰符

修饰符@的作用： 是为现有函数增加额外的功能，常用于插入日志、性能测试、事务处理等等。

创建函数修饰符的规则：

• 修饰符是一个函数
• 修饰符取被修饰函数为参数
• 修饰符返回一个新函数
• 修饰符维护被维护函数的签名

def say():
    # print('*********')
    print('hello')
def hello():
    print('!!!!!!!!!!!!!!hello')

def fun(f):  ##引用函数
    def inner():
        print('*********')
        f()
        print('############')
    return inner
@fun  ##@修饰符就是把hello（）函数传递给fun（）装饰器函数
def hello(): 
    print('!!!!!!!!!!!!!!hello')

say()

say = fun(say)
print(say)

hello()

hello = fun(hello)
hello()

def outer(f):
    def inner(age):
        if age <= 0:
            age = 0
        f(age)

    return inner


@outer
def say(age):
    print('year old:', age)


say(-1)
say(2)

3. 使用装饰器实现一个函数计时器

方法	说明
@functools.wraps(func)	这是python提供的装饰器。它能把原函数的元信息拷贝到装饰器里面的 func 函数中。函数的元信息包括docstring、name、参数列表等等。可以尝试去除@functools.wraps(func)，你会发现test.__name__的输出变成了wrapper。

作者：聪明叉
链接：https://www.jianshu.com/p/ee82b941772a
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 |

import time
import random
import string
import functools

li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):  # 接收可变参数 和关键字参数
        """这是一个装饰器timeit"""
        # 在函数运行执行
        start_time = time.time()  ##返回当前时间的时间戳
        # 执行函数
        res = func(*args, **kwargs)
        # 在函数运行之后
        end_time = time.time()
        print('运行时间为:%.6f' % (end_time - start_time))
        return res

    return wrapper

@timeit
def con_add():
    s = ''
    for i in li:
        s += (i + ',')
    print(s)

@timeit
def join_add():
    print(','.join(li))

con_add()
join_add()

@timeit
def fun_list(n):
    """这是fun_list函数"""
    return [2 * i for i in range(n)]
@timeit
def fun_map(n):
    """这是fun_map函数"""
    return list(map(lambda x:x*2,range(n)))

fun_list(100000)
fun_map(100000)

print(fun_map.__doc__)
print(fun_list.__doc__)  #查看函数的说明文字
print(fun_map.__name__)  #显示当前函数的入口
print(fun_list.__name__)

4. 创建装饰器1

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

import time
import functools

def add_log(func):
    @functools.wraps(func)
    def wrapper(*args,**kwargs):

        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print('[%s] 函数名:%s,运行时间:%.6f,运行返回值的结果'
              ':%d' %(time.ctime(),func.__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)

4. 创建装饰器2

一层一层修饰

def wrapper_out1(func):
    # print('--out11---')
    def inner1(*args,**kwargs):
        print('----in11----')
        res = func(*args,**kwargs)
        print('----in12-----')
        return res
    # print('---out---12')
    return inner1

def wrapper_out2(func):
    # print('--out21---')
    def inner2(*args,**kwargs):
        print('----in21----')
        res = func(*args,**kwargs)
        print('----in22-----')
        return res
    # print('---out---22')
    return inner2

@wrapper_out2
@wrapper_out1
def test(): #wrapper_out2(wrapper_out1(test)) === wrapper_out2(inner1)
    print('---test---')
    return 1 * 2

test()
print(test)

5. 创建装饰器3

import functools
import inspect

login_session = ['root', 'admin', 'redhat']


def is_login(fun):
    @functools.wraps(fun)
    def warapper(*args, **kwargs):  # ('root',)
        if args[0] in login_session:
            temp = fun(*args, **kwargs)
            return temp
        else:
            print('Error:%s 没哟登陆成功' % (args[0]))

    return warapper

def is_admin(fun):
    @functools.wraps(fun)
    # """
    #  inspect.getcallargs会返回一个字典
    #  key:形参
    #  value:对应的实参
    #  inspect.getcallargs 返回一个字典，字典里保存了函数所有的参数
    #  inspect.getcallargs(func[, *args][, **kwds])：将args和kwds参数到绑定到为func
    #  的参数名；对bound方法，也绑定第一个参数（通常为self）到相应的实例；返回字典，
    #  对应参数名及其值；
    # """
    def wrapper(*args,**kwargs):
        inspect_res = inspect.getcallargs(fun,*args,**kwargs)
        print('inspect的返回值是:%s' %(inspect_res))
        if inspect_res.get('name') == 'root':
            temp = fun(*args,**kwargs)
            return temp
        else:
            print('not root user,no permisson add user')
    return wrapper

@is_login
@is_admin
def add_user(name): # is_login((is_admin(adduser)) is_login(wrapper())
    print('add_user')

add_user('root')
add_user('admin')
add_user('haha')

6. 创建装饰器4

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

• 确保函数接收到的每一个参数都是整数;
• 如果参数不是整形数， 打印 TypeError:参数必须为整形

用法	说明
isinstance(object, classinfo)	来判断一个对象是否是一个已知的类型, object – 实例对象,classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组,如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

import functools
def required_ints(func):
    @functools.wraps(func)
    def wrapper(*args,**kwargs): # (1,2,....)
        for i in args:
            # if isinstance(i,int):
            #     pass
            # else:
            #     print('函数所有的参数并非全是int型')

            if not  isinstance(i,int):
                print('函数所有的参数并非都是int型')
                break
        else:
            res = func(*args,**kwargs)
            return res

    return wrapper

@required_ints
def add(a,b):
    return a+b
@required_ints
def mymax(a,b,c,d):
    return max(a,b,c,d)

print(add(1,2))
print(add(1,2.5))
print(mymax(1,4,3,2))

7. 带参数的装饰器

import time
import functools

def log(kind):
    def add_log(func):
        @functools.wraps(func)
        def wrapper(*args,**kwargs):

            start_time = time.time()
            res = func(*args,**kwargs)
            end_time = time.time()
            print('<%s> [%s] 函数名:%s,运行时间:%.6f,运行返回值的结果'
              ':%d' %(kind,time.ctime(),func.__name__,
                      end_time-start_time,res))
            return res
        return wrapper
    return add_log

@log('debug')
def add(x,y):
    time.sleep(1)
    return x+y

add(1,10)

8. 多个装饰器的练习

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

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

import functools
def required_type(*kind):
    def require(fun):
        @functools.wraps(fun)
        def wrapper(*args,**kwargs):
            for i in args:
                if not isinstance(i,kind):
                    print('函数所有的参数并非',kind)
                    break
            else:
                res = fun(*args,**kwargs)
                return res
        return wrapper
    return require
# a = 1.0
# print(isinstance(a,(int,float)))
@required_type(int,float)
def add(a,b):
    return a+b

print(add(1,'o'))
print(add(1,4))