装饰器及例题分析

知识点：

装饰器的定义：
- 装饰器的实现是函数里面嵌套函数;
- 装饰器的本质是一个函数， 它可以让其他函数在不需要做任何代码改动的前提下增加额外的功能;
- 装饰器需要传递一个函数， 返回值也是一个函数对象.

1、map函数

def f(x):
    return x * x

"""
 map()传入的第一个参数是一个函数，第二个参数是一个序列，第二个序列作为第一个参数的输入值
也就是说第二个参数调用了第一个函数
"""

print map(f, [1, 2, 3, 4])

2、匿名函数

#上面的函数也可以用一条语句代替，即匿名函数lambdax:

print map(lambda x: x * x, [1, 2, 3, 4])

3、带有参数的装饰器：

import functools
import time

# 打印当前的时间
print time.ctime()


def log(name):
    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] 函数名:%s,运行时间:%.5f,运行返回值结果:%d' %(
                name, time.ctime(), fun.__name__, end_time - start_time, res)
            return res

        return wrapper

    return add_log


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

print add(1,2)

4、多个装饰器的执行顺序

#定义两个装饰器，将两个装饰器给函数，探究其中调用的先后顺序

def decorator_a(func):
    print 'Get in decorator_a'

    def inner_a(*args, **kwargs):
        print 'Get in inner_a'
        res = func(*args, **kwargs)
        return res

    return inner_a


def decorator_b(func):
    print 'Get in decorator_b'

    def inner_b(*args, **kwargs):
        print 'Get in inner_b'
        res = func(*args, **kwargs)
        return res

    return inner_b


# 当有多个装饰器时，从下到上调用装饰器
@decorator_a
@decorator_b
def f(x):
    print 'Get in f'
    return x * 2

f(1)

 

总结：

从运行结果可以看出，若将decorator_a和decorator_b按顺序给函数，则装饰器外部为从下岛上调用装饰器，内部仍按顺序调用。

例题分析：

1、多个装饰器的应用

要求：查看若要实现相同的功能python内置函数和自己编写的函数哪个运行时间更少

装饰器需求：获取每个函数的执行时间

1.函数执行之前计算时间

2.函数执行之后计算时间

3.运行时间=执行后时间-执行前时间

问题1：被装饰的函数有返回值的时候怎么办？

问题2：如何保留被装饰函数的函数名和帮助文档信息

import functools
import random
import string
import time

"""导入模块的快捷键为Alt+Enter并选择"""
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    """装饰器"""

    @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函数，被timeit装饰"""
    return [2 * i for i in range(n)]

@timeit
def fun_map(n):
    """这是fun_map函数"""
    return list(map(lambda x: x * 2, range(n)))

# 匿名函数
# map传入的第一个参数为一个函数，第二个为一个序列

con_add()
join_add()
print fun_list(50000)
print fun_map(50000)

#保留被装饰函数的函数名和帮助文档信息
print fun_list.__name__
print fun_list.__doc__

总结：从上面的运行时间可以看出：

用python的内置函数比自己编写的函数运行时间少，所以我们在调用函数的时候尽量使用python的内置函数。

 

2、

在我们实际的应用中，会应用到多个装饰器，例如： 先验证是否登陆成功再验证权限的方法

要求：用户登陆验证的装饰器 is_login

           1.如果用户登陆成功，则执行被装饰的函数

           2.如果用户登陆不成功，则执行登陆函数

import functools
# 让函数统一
import inspect


def is_root(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        inspect_res = inspect.getcallargs(fun, *args, **kwargs)
        print 'inspect_res的返回值：%s' % inspect_res
        if inspect_res.get('name') == 'root':
            res = fun(*args, **kwargs)
            return res
        else:
            print 'Error:no perminssion add student'

    return wrapper


def is_login(fun):
    @functools.wraps(fun)
    def warrper(*args, **kwargs):
        if args[0] in login_session:
            res = fun(*args, **kwargs)
            return res
        else:
            print 'Error:%s未登陆'

    return warrper


@is_login
@is_root
def add_student(name):
    print '添加学生信息'


login_session = ['root', 'admin', 'redhat']
# 调用函数
add_student('root')

3、

要求：用户登陆验证的装饰器 is_login

           1.如果用户登陆成功，则执行被装饰的函数

           2.如果用户登陆不成功，则执行登陆函数

import functools

login_users = ['admin', 'root']


def is_login(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        # 判断写博客这个用户是否登陆成功
        if kwargs.get('name') in login_users:
            res = fun(*args, **kwargs)
            return res
        else:
            res = login()
            return res

    return wrapper


def login():
    return '登陆。。。'


@is_login
def writeBlog(name):
    return '编写博客。。'

print writeBlog(name='admin')

若最后调用函数时为：

print  writeBlog(name='admin')

4、

要求：

创建装饰器， 要求如下：

1. 创建add_log装饰器， 被装饰的函数打印日志信息；

2. 日志格式为: [字符串时间] 函数名: xxx， 运行时间：xxx, 运行返回值结果:xxx

import time
import functools
#print time.ctime()

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

print add(1,2)

5、

编写装饰器required_ints, 条件如下:
 1). 确保函数接收到的每一个参数都是整数;
 2). 如果参数不是整形数， 打印 TypeError:参数必须为整形

import functools

def required_ints(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        for i in args:
            if not isinstance(i, int):
                print 'TypeError:参数必须为整形'
                break
        else:
            res = fun(*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 myMax(1,2,3,4)

6、

要求：编写装饰器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(*kinds):
    def required_ints(fun):
        @functools.wraps(fun)
        def wrapper(*args, **kwargs):
            for i in args:
                if not isinstance(i, kinds):
                    print 'TypeError:参数必须为',kinds
                    break
            else:
                res = fun(*args, **kwargs)
                return res
        return wrapper
    return required_ints

@required_types(float,float)
def add(a, b):
    return a + b

print add(1.1,3)