函数的装饰器

函数的装饰器

1.在不改变原函数的基础上增加功能

现在有一个函数用于输出hello world要求在函数前加一行*****，但是你又不想进入函数改，这时就用到装饰器

# _*_ coding:utf-8 _*_
"""
file: test.py
date: 2018-09-10 10:04 AM
"""
#原函数输出
def func1():
    print 'hello world'
#装饰器
def outer(func):
    def inter():
        print '*******'
        func1()
    return inter
f=outer(func1)
f()

##函数实现了在求和的函数上面添加两句输出
def outer(func):
    def inner(num1, num2):
        print 'hello world'
        result = func(num1, num2)
        print 'hello python'
        return result
    return inner
#语法糖装饰器的引用，用outer给func1函数加上装饰器
@outer
def func1(num1, num2):
    return num1 + num2
#接收函数的返回值
response = func1(2, 3)
print response

2.string包函数可以输出a-z大小写字母

import string
print string.ascii_letters

输出结果：

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

3.装饰器需求：获取每个函数的执行时间
    1.函数执行之前计算时间
    2.函数执行之后计算时间

问题1：被装饰的函数有返回值的时候怎么办？
问题2：如何保留被装饰函数的函数名和帮助文档信息

# _*_ coding:utf-8 _*_
"""
file:函数装饰器02.py
date:2018-09-10-10:28 AM
"""
import  time
import random
import functools
import string
li = [random.choice(string.ascii_letters) for i in range(100)]

def timeit(fun):
    """这是一个装饰器"""
    @functools.wraps(fun)
    def wrapper(*arg,**kwargs):
        """这是一个wrapper函数"""
        #args:元组 kwargs:字典
        #在函数执行前
        start_time = time.time()
        #执行函数
        #接收被装饰函数的返回值
        res = fun(*arg,**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()

运行结果可以看出Python的内置函数效率较高，所以尽量用内置函数提高效率

在以上函数中添加如下几行回答1，2题

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

print fun_list(5000)
print fun_list.__name__
print fun_list.__doc__

没有@functools.wraps(fun)函数会直接返回装饰器里的注释，如果有的话保留被装饰函数的函数名和帮助文档信息

装饰器练习一：

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

# _*_ coding:utf-8 _*_
"""
file:装饰器03.py
date:2018-09-10-11:02 AM
"""
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')

运行结果：存在admin登录成功，不存在的用户admins登录失败，

装饰器练习二：

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

# _*_ coding:utf-8 _*_
"""
file:装饰器练习04.py
date:2018-09-10-11:21 AM
"""
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，运行时间：%.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)

结果输出：

装饰器练习三：

编写装饰器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
print add(9,12.8)

装饰器练习四：

编写装饰器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)

探究多个装饰器的执行顺序

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_b
@decorator_a
def f(x):
    print 'Get in f'
    return x * 2

f(1)