python 装饰器详解

1. 概述

• 装饰器是一个很著名的设计模式， 经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。
• 装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。
• 概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

2. demo详解

• ftime 以函数的形式定义装饰器,不支持参数
• ftimeParam 以函数的形式定义装饰器,支持装饰器参数
• Fuctime 以类的形式定义装饰器,不支持参数
• FuctimeParam 以类的形式定义装饰器，支持装饰器参数
• 主要关注如下:

  • print add1(1, 2, 3), ftimeParam(1, 3)(add)(1, 2, 3)

  • print add2(1, 2, 3), ftime(add)(1, 2, 3)

  • print add3(1, 2, 3), Fuctime(add)(1, 2, 3)

  • print add4(1, 2, 3), FuctimeParam(1, 2)(add)(1, 2, 3)

    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    
    import functools
    import time
    
    
    def ftime(func):
        '''
            以函数的形式定义装饰器,不支持参数
        '''
        func.original_func = func
    
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            t = time.clock()
            result = func(*args, **kwargs)
            wrapper.fcostime = time.clock() - t
            return result
        return wrapper
    
    
    def ftimeParam(*args, **kwargs):
        '''
            以函数的形式定义装饰器,支持装饰器参数
        '''
    
        def decorator(func):
            func.original_func = func
    
            @functools.wraps(func)
            def wrapper(*args, **kwargs):
                t = time.clock()
                result = func(*args, **kwargs)
                wrapper.fcostime = time.clock() - t
                return result
            return wrapper
        return decorator
    
    
    class Fuctime(object):
        """以类的形式定义装饰器,不支持参数"""
    
        def __init__(self, func):
            super(Fuctime, self).__init__()
            self.original_func = func
    
        def __call__(self, *args, **kwargs):
            t = time.clock()
            result = self.original_func(*args, **kwargs)
            self.fcostime = time.clock() - t
            return result
    
    
    class FuctimeParam(object):
        """以类的形式定义装饰器，支持装饰器参数"""
        def __init__(self, *args, **kwargs):
            super(FuctimeParam, self).__init__()
            self.args = args
            self.kwargs = kwargs
    
        def __call__(self, func):
            func.original_func = func
    
            @functools.wraps(func)
            def wrapper(*args, **kwargs):
                t = time.clock()
                result = func(*args, **kwargs)
                wrapper.fcostime = time.clock() - t
                return result
            return wrapper
    
    
    @ftimeParam(1, 3)
    def add1(a, b, c=10, d=15):
        '''
            add a+b+c+d
        '''
        return a + b + c + d
    
    
    @ftime
    def add2(a, b, c=10, d=15):
        '''
            add a+b+c+d
        '''
        return a + b + c + d
    
    
    @Fuctime
    def add3(a, b, c=10, d=15):
        '''
            add a+b+c+d
        '''
        return a + b + c + d
    
    
    @FuctimeParam(1, 2)
    def add4(a, b, c=10, d=15):
        '''
            add a+b+c+d
        '''
        return a + b + c + d
    
    
    def add(a, b, c=10, d=15):
        '''
            add a+b+c+d
        '''
        return a + b + c + d
    
    
    print add1, add1.original_func, add1.original_func(1, 2, 3), add1(1, 2, 3)
    
    print add2, add2.original_func, add1.original_func(1, 2, 3), add2(1, 2, 3)
    
    print add3, add3.original_func, add1.original_func(1, 2, 3), add3(1, 2, 3)
    
    print add4, add4.original_func, add1.original_func(1, 2, 3), add4(1, 2, 3)
    
    print add1.fcostime
    print add2.fcostime
    print add3.fcostime
    print add4.fcostime
    
    print add1(1, 2, 3), ftimeParam(1, 3)(add)(1, 2, 3)
    print add2(1, 2, 3), ftime(add)(1, 2, 3)
    print add3(1, 2, 3), Fuctime(add)(1, 2, 3)
    print add4(1, 2, 3), FuctimeParam(1, 2)(add)(1, 2, 3)