装饰器

装饰器定义

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

装饰器举例

例一：

def func3():
    print('have a nice day!')


def outer(func):
    def inner():
        print('~~~~~~~~~~~')
        func()
    return inner

func3 = outer(func3)
func3()

例二：

def outer(func):
    def inner(age):
        if age < 0:
            age = 0
        func(age)
    return inner


@outer #语法糖  #say=outer(say)
# 使用@符号将装饰器应用到函数
def say(age):
    print('man is %d years old' %(age))

say(-100)    #调用原有函数

例三：

#模拟银行管理系统

def desc(fun):  # 需要传递一个函数，要装饰的函数
    def add_info():  # 装饰器函数里要嵌套函数
        print('元旦快乐～')
        fun()
        #print('欢迎光临西部开源～')
    return add_info    # 返回值是嵌套的函数对象

@desc   # 如何调用装饰器(两种方式)
def login():
    print('login....')

# login = desc(login)  # 返回值是一个函数
# login()
@desc
def logout():
    print('logout...')

@desc
def savemoney():
    print('存钱...')

@desc
def transfermoney():
    print('转账...')


login()
logout()
savemoney()
transfermoney()

例四：

# 装饰器实现一个计时器
import time
import string
import random
import functools

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

# 问题1：装饰的函数有返回值
# 问题2：如何保留被装饰函数的函数名和帮助信息文档
def timeit(fun):
    """这是一个装饰器timeit"""
    @functools.wraps(fun) #可以保留被装饰函数的函数名和帮助信息文档
    def wrapper(*args, **kwargs):  # 接收可变参数和关键字参数
        """这是一个wrapper函数"""
        # args:元组  kwargs:字典
        # 在函数执行之前
        start_time = time.time()
        # 执行函数
        res = fun(*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))

@timeit
def fun_list(n):
    """这是fun_list函数，被timeis装饰"""
    return [2 * i for i in range(n)]

@timeit
def fun_map(n):
    """这是fun_map函数，被timeis装饰"""
    return map(lambda x:x*2,range(n))

def fun():
    """这是fun函数"""
    print('hello')
# con_add()
# join_add()

# print(fun_list(100))
# print(fun_map(100))

print(fun.__doc__)
print(fun.__name__)

print(fun_list.__doc__)
print(fun_map.__doc__)
print(fun_list.__name__)
print(fun_map.__name__)

例五：

import functools
import inspect


def is_admin(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        # inspect.getcallargs返回一个字典，key值：形参 value值：对应的实参
        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 stduent')
    return wrapper

@is_admin
def add_student(name):
    print('添加学生信息～')

@is_admin
def del_student(name):
    print('删除学生信息～')

add_student('linux')
del_student('python')

例六：

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

import functools
import time
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,运行时间:%.5f,运行返回值结果:%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)

例七：

def decorator_a(fun):
    print('Get in decorator_a')
    def inner_a(*args,**kwargs):
        print('Get in inner_a')
        return fun(*args,**kwargs)
    return inner_a

def decorator_b(fun):
    print('Get in decorator_b')
    def inner_b(*args,**kwargs):
        print('Get in inner_b')
        return fun(*args,**kwargs)
    return inner_b

"""
当有多个装饰器的时候，从下到上调用
真实的warpper内容是从上到下执行的
"""
@decorator_b
@decorator_a
def f(x):
    print('Gat in f')
    return x * 2

f(1)

例八：

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

def required_types(*type):
    def required_type(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for i in args:
                if isinstance(i, type):
                    pass
                else:
                    print('TypeError:参数必须为%s类型' % ([i for i in type]))
                    exit()
            res = func(*args)
            print(res)
            return res

        return wrapper

    return required_type

@required_types(int, float)
def get(*args):
    return args

get(sorted)