Python装饰器分类

Python

装饰器函数: 是指装饰器本身是函数风格的实现;

函数装饰器: 是指被装饰的目标对象是函数;(目标对象);

装饰器类 : 是指装饰器本身是类风格的实现;

类装饰器 : 是指被装饰的目标对象是类;(目标对象);

装饰器函数

目标对象是函数

(1)、装饰器无参数

A、目标无参数

strOldFunctionName = "";

strNewFunctionName = "";

#装饰器无参数:

def decorator(callback): #装饰器函数/外部函数,它接受一个函数对象作为参数(这个函数一般就是目标函数);

    #目标无参数:

    def wrapper():       #闭包函数,用于传递目标函数的所有参数(没有参数);

        strOldFunctionName = callback.__name__;

        print "装饰前的函数名: %s" % strOldFunctionName;

        print "enter {}()".format(callback.__name__);

        callback();      #调用目标函数,执行原有功能;

        print "leave {}()".format(callback.__name__);

        pass;

    return wrapper;      #返回闭包函数对象;

@decorator  #装饰器无参数;

def target():  #目标函数:需要增加功能的函数(没有参数);

    strNewFunctionName = target.__name__;

    print "装饰后的函数名: %s" % strNewFunctionName;

    pass;

target(); #用装饰过的新函数;

print "函数名变化: %s --> %s" % (strOldFunctionName, strNewFunctionName)

B、目标有参数

strOldFunctionName = "";

strNewFunctionName = "";

#装饰器无参数:

def decorator(callback):           #装饰器函数/外部函数,它接受一个函数对象作为参数(这个函数一般就是目标函数);

    #目标有参数:

    def wrapper(*args, **kwargs):  #闭包函数,用于传递目标函数的所有参数(任意参数);

        strOldFunctionName = callback.__name__;

        print "装饰前的函数名: %s" % strOldFunctionName;

        print "enter {}()".format(callback.__name__);

        callback(*args, **kwargs); #调用目标函数,执行原有功能;

        print "leave {}()".format(callback.__name__);

        pass;

    return wrapper;  #返回闭包函数对象;

@decorator #装饰器无参数;

def target0(): #目标函数:需要增加功能的函数(没有参数) ;

    strNewFunctionName = target0.__name__;

    print "装饰后的函数名target0 = %s" % strNewFunctionName;

    pass;

@decorator #装饰器无参数;

def target1(a): #目标函数:需要增加功能的函数(1个参数) ;

    print "a = ", a;

    strNewFunctionName = target1.__name__;

    print "装饰后的函数名target1 = %s" % strNewFunctionName;

    pass;

@decorator #装饰器无参数;

def target2(a, b): #目标函数:需要增加功能的函数(2个参数) ;

    print "a = ", a, ", b = ", b;

    strNewFunctionName = target2.__name__;

    print "装饰后的函数名target2 = %s" % strNewFunctionName;

    pass;

target0();     #调用装饰过的新函数;

target1(6);    #调用装饰过的新函数;

target2(2, 8); #调用装饰过的新函数;

(2)、装饰器有参数

A、目标无参数

strOldFunctionName = "";

strNewFunctionName = "";

#装饰器有参数:

def decorator(name):       #装饰器函数,参数name可以作为关键字使用(可选的特点);

    def wrapper(callback): #内嵌一级闭包函数wrapper(),用于传递目标函数对象;接受一个函数对象作为参数(这个函数一般就是目标函数);

        #目标无参数:

        def _wrapper(): #二级闭包函数_wrapper()用于传递目标函数的所有参数(没有参数);

            strOldFunctionName = callback.__name__;

            print "装饰前的函数名: %s" % strOldFunctionName;

            print "{name}: enter {func}()".format(name = name, func = callback.__name__); #打印输出:通过关键字模式"{name}"打印,关键字name与format()的name关键字参数相同,func雷同;

            callback(); #调用目标函数,执行原有功能(没有参数);

            print "{name}: leave {func}!".format(name = name, func = callback.__name__);  #打印输出:通过关键字模式"{name}"打印,关键字name与format()的name关键字参数相同,func雷同;

            pass;

        return _wrapper; #在一级闭包函数中返回二级闭包函数对象;

    return wrapper; #在装饰器函数中返回一级闭包函数对象;

#装饰器有参数:

@decorator(name = "SYSTEM")  #装饰目标函数,参数name被用作关键字参数传递(可选参数的特点);

def target(): #目标无参数;

    strNewFunctionName = target.__name__;

    print "装饰后的函数名target = %s" % strNewFunctionName;

    pass;

target(); #调用装饰过的新函数;

B、目标有参数

strOldFunctionName = "";

strNewFunctionName = "";

#装饰器有参数:

def decorator(name):       #装饰器函数,参数name可以作为关键字使用(可选的特点);

    def wrapper(callback): #内嵌一级闭包函数wrapper(),用于传递目标函数对象;接受一个函数对象作为参数(这个函数一般就是目标函数);

        #目标有参数:

        def _wrapper(*args, **kwargs): #二级闭包函数_wrapper()用于传递目标函数的所有参数;

            strOldFunctionName = callback.__name__;

            print "装饰前的函数名: %s" % strOldFunctionName;

            print "{name}: enter {func}()".format(name = name, func = callback.__name__); #打印输出:通过关键字模式"{name}"打印,关键字name与format()的name关键字参数相同,func雷同;

            callback(*args, **kwargs); #调用目标函数,执行原有功能;

            print "{name}: leave {func}!".format(name = name, func = callback.__name__);  #打印输出:通过关键字模式"{name}"打印,关键字name与format()的name关键字参数相同,func雷同;

            pass;

        return _wrapper; #在一级闭包函数中返回二级闭包函数对象;

    return wrapper; #在装饰器函数中返回一级闭包函数对象;

#装饰器有参数:

@decorator(name = 'SYSTEM') #装饰目标函数,参数name被用作关键字参数传递(可选参数的特点);

def target3(a, b, c):

    strNewFunctionName = target3.__name__;

    print "装饰后的函数名target = %s" % strNewFunctionName;

    print "a = %d, b = %d, c = %d" % (a, b, c);

    pass;

#装饰器有参数:

@decorator('PROCESS')       #装饰目标函数,参数name没有被用作关键字参数传递;

def target2(x, y):

    strNewFunctionName = target2.__name__;

    print "装饰后的函数名target = %s" % strNewFunctionName;

    print "x = %d, y = %d" % (x, y);

    pass;

target2(6, 8);    #调用装饰过的新函数;

target3(4, 6, 8); #调用装饰过的新函数;

目标对象是类

(1)、装饰器无参数

A、目标无参数

strOldClassName = "";

strNewClassName = "";

#装饰器无参数:

def decorator(cls): #装饰器,它没有参数,只是接受类对象作为参数(被装饰的目标类);

    #目标无参数:

    def wrapper(): #一级闭包函数,它负责传递类的构造函数需要用到的参数(没有参数);

        strOldClassName = cls.__name__;

        print "装饰前的类名: %s" % strOldClassName;

        print "call {name}.__init__".format(name = cls.__name__);

        objCls = cls(); #调用原始类的构造函数(没有参数);

        return objCls;  #返回新的类对象(被装饰过的目标类对象);

    return wrapper; #返回一级闭包函数对象;

@decorator

class target:

    def __init__(self): #目标无参数;

        strNewClassName = target.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t = target(); #用装饰过的新类创建对象;

t.echo("XXXXXXXXXXXX");

B、目标有参数

strOldClassName = "";

strNewClassName = "";

#装饰器无参数:

def decorator(cls): #装饰器,它没有参数,只是接受类对象作为参数(被装饰的目标类);

    #目标有参数:

    def wrapper(*args, **kwargs): #一级闭包函数,它负责传递类的构造函数需要用到的参数;

        strOldClassName = cls.__name__;

        print "装饰前的类名: %s" % strOldClassName;

        print "call {name}.__init__".format(name = cls.__name__);

        objCls = cls(*args, **kwargs); #调用原始类的构造函数;

        return objCls;  #返回新的类对象(被装饰过的目标类对象);

    return wrapper; #返回一级闭包函数对象;

@decorator

class target1:

    def __init__(self, arg): #目标有参数;

        self.arg = arg;

        print "arg = ", arg;

        strNewClassName = target1.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator

class target2:

    def __init__(self, arg1, arg2): #目标有参数;

        self.arg1 = arg1;

        self.arg2 = arg2;

        print "arg1 = ", self.arg1, ", arg2 = ", self.arg2;

        strNewClassName = target2.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator

class target3:

    def __init__(self): #目标无参数;

        strNewClassName = target3.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t1 = target1(123);      #用装饰过的新类创建对象;

t1.echo("");

t2 = target2(456, 789); #用装饰过的新类创建对象;

t1.echo("");

t3 = target3();         #用装饰过的新类创建对象;

t3.echo("");

(2)、装饰器有参数

A、目标无参数

strOldClassName = "";

strNewClassName = "";

#装饰器有参数:

def decorator(level = 'INFO'): #装饰器,它需要参数;

    def _wrapper(cls):         #一级闭包函数对象,它接受一个类(被装饰的目标类)对象(类也是对象)作为参数;

        #目标无参数:

        def __wrapper(): #二级闭包函数,它负责传递类的构造函数需要用到的参数(没有参数);

            strOldClassName = cls.__name__;

            print "装饰前的类名: %s" % strOldClassName;

            print "[{level}] call {name}.__init__".format(level = level, name = cls.__name__);

            objCls = cls(); #调用原始类的构造函数(没有参数);

            return objCls;  #返回新的类对象(被装饰过的目标类对象);

        return __wrapper;   #返回二级闭包函数对象;

    return _wrapper; #返回一级闭包函数对象;

@decorator()

class target1:

    def __init__(self): #目标无参数;

        strNewClassName = target1.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator("DEBUG")

class target2:

    def __init__(self): #目标无参数;

        strNewClassName = target2.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator(level = "SYSTEM")

class target3:

    def __init__(self): #目标无参数;

        strNewClassName = target3.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t1 = target1(); #用装饰过的新类创建对象;

t1.echo("AAAAAAAA");

t2 = target2(); #用装饰过的新类创建对象;

t2.echo("BBBBBBBB");

t3 = target3(); #用装饰过的新类创建对象;

t3.echo("CCCCCCCC");

B、目标有参数

strOldClassName = "";

strNewClassName = "";

#装饰器有参数:

def decorator(level = 'INFO'): #装饰器,它需要参数;

    def _wrapper(cls):         #一级闭包函数对象,它接受一个类(被装饰的目标类)对象(类也是对象)作为参数;

        #目标有参数:

        def __wrapper(*args, **kwargs): #二级闭包函数,它负责传递类的构造函数需要用到的参数;

            strOldClassName = cls.__name__;

            print "装饰前的类名: %s" % strOldClassName;

            print "[{level}] call {name}.__init__".format(level = level, name = cls.__name__);

            objCls = cls(*args, **kwargs); #调用原始类的构造函数;

            return objCls;  #返回新的类对象(被装饰过的目标类对象);

        return __wrapper;   #返回二级闭包函数对象;

    return _wrapper; #返回一级闭包函数对象;

@decorator()

class target1:

    def __init__(self, arg):

        self.arg = arg;

        print "arg = ", arg;

        strNewClassName = target1.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator('ERROR')

class target2:

    def __init__(self, arg1, arg2):

        self.arg1 = arg1;

        self.arg2 = arg2;

        print "arg1 = ", self.arg1, ", arg2 = ", self.arg2;

        strNewClassName = target2.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator(level = 'WARN')

class target3:

    def __init__(self):

        strNewClassName = target3.__name__;

        print "装饰后的类名: %s" % strNewClassName;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t1 = target1(123);      #用装饰过的新类创建对象;

t1.echo("");

t2 = target2(456, 789); #用装饰过的新类创建对象;

t1.echo("");

t3 = target3();         #用装饰过的新类创建对象;

t3.echo("");

装饰器类

装饰器本身是一个类,通过构造函数__init__()和回调函数__call__()实现装饰器功能

目标对象是函数

(1)、装饰器无参数

A、目标无参数

#装饰器无参数:

class decorator:  #装饰器类,它也可以从object继承"class decorator(object)";

    def __init__(self, callback): #在构造函数里面接受callback对象(原始目标函数对象)作为参数;

        self.callback = callback;

        self.__name__ = callback.__name__; #保证被装饰之后函数名字不变;

        pass;

    #目标无参数:

    def __call__(self): #在__call__()函数中传递目标函数对象的所有参数(没有参数);

        print "装饰前的函数名: %s" % self.callback.__name__;

        print "enter {func}()".format(func = self.callback.__name__);

        result = self.callback();

        print "leave {func}()".format(func = self.callback.__name__);

        return result;

@decorator

def target():

    print "装饰后的函数名: %s" % target.__name__;

    pass;

target(); #调用装饰过的新函数;

B、目标有参数

#装饰器无参数:

class decorator:  #装饰器类,它也可以从object继承"class decorator(object)";

    def __init__(self, callback): #在构造函数里面接受callback对象(原始目标函数对象)作为参数;

        self.callback = callback;

        self.__name__ = callback.__name__; #保证被装饰之后函数名字不变;

        pass;

    #目标有参数:

    def __call__(self, *args, **kwargs): #在__call__()函数中传递目标函数对象的所有参数(任意参数);

        print "装饰前的函数名: %s" % self.callback.__name__;

        print "enter {func}()".format(func = self.callback.__name__);

        result = self.callback(*args, **kwargs); #传递任意参数;

        print "leave {func}()".format(func = self.callback.__name__);

        return result;

@decorator

def target0():

    print "装饰后的函数名: %s" % target0.__name__;

    pass;

@decorator

def target1(a, b):

    print "a = %d, b = %d" % (a, b);

    print "装饰后的函数名: %s" % target1.__name__;

    pass;

target0();     #调用装饰过的新函数;

target1(6, 8); #调用装饰过的新函数;

(2)、装饰器有参数

A、目标无参数

#装饰器有参数:

class decorator:

    def __init__(self, name = 'INFO'): #在装饰器的构造函数中传递装饰器类需要的参数;

        self.name = name;

        pass;

    #目标无参数:

    def __call__(self, callback): #在__call__()函数中接受callback对象(原始目标函数对象)作为参数;

        def wrapper(): #内部闭包函数,给目标函数增加额外的功能(没有参数);

            print "装饰后的函数名: %s" % callback.__name__;

            print "[{name}] enter {func}()".format(name = self.name, func = callback.__name__);

            result = callback();  #调用原始目标函数,没有参数;

            print "[{name}] leave {func}()".format(name = self.name, func = callback.__name__);

            return result;

        return wrapper; #返回新的目标函数对象;

@decorator()

def target0():

    print "装饰后的函数名: %s" % target0.__name__;

    pass;

@decorator('ERROR')

def target1():

    print "装饰后的函数名: %s" % target1.__name__;

    pass;

@decorator(name = 'SYSTEM')

def target2():

    print "装饰后的函数名: %s" % target2.__name__;

    pass;

target0(); #调用装饰过的新函数;

target1(); #调用装饰过的新函数;

target2(); #调用装饰过的新函数;

B、目标有参数

#装饰器有参数:

class decorator:

    def __init__(self, name = 'INFO'): #在装饰器的构造函数中传递装饰器类需要的参数;

        self.name = name;

        pass;

    #目标有参数:

    def __call__(self, callback): #在__call__()函数中接受callback对象(原始目标函数对象)作为参数;

        def wrapper(*args, **kwargs): #内部闭包函数,给目标函数增加额外的功能(任意参数);

            print "装饰后的函数名: %s" % callback.__name__;

            print "[{name}] enter {func}()".format(name = self.name, func = callback.__name__);

            result = callback(*args, **kwargs);  #调用原始目标函数,传递任意参数;

            print "[{name}] leave {func}()".format(name = self.name, func = callback.__name__);

            return result;

        return wrapper; #返回新的目标函数对象;

@decorator()

def target0():

    print "装饰后的函数名: %s" % target0.__name__;

    pass;

@decorator('ERROR')

def target1(a):

    print "装饰后的函数名: %s" % target1.__name__;

    print "a = %d" % (a);

    pass;

@decorator(name = 'SYSTEM')

def target2(x, y):

    print "装饰后的函数名: %s" % target2.__name__;

    print "x = %d, y = %d" % (x, y);

    pass;

target0();     #调用装饰过的新函数;

target1(2);    #调用装饰过的新函数;

target2(6, 8); #调用装饰过的新函数;

目标对象是类

(1)、装饰器无参数

A、目标无参数

#装饰器无参数:

class decorator:

    def __init__(self, cls): #在装饰器的构造函数中传递被装饰类的对象;

        self.cls = cls;

        self.__name__ = cls.__name__; #保证被装饰之后类的名字不变;

        pass;

    #目标无参数:

    def __call__(self): #在__call__()函数中接受callback对象(原始目标函数对象)的所有参数(没有参数);

        print "装饰前的类名: %s" % self.cls.__name__;

        print "enter {func}()".format(func = self.cls.__name__);

        objCls = self.cls();  #调用原始类的构造函数,传递任意参数(没有参数);

        print "leave {func}()".format(func = self.cls.__name__);

        return objCls; #返回新的目标类对象;

@decorator #装饰器无参数;

class target:

    def __init__(self): #目标无参数;

        print "装饰后的类名: %s" % target.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t = target(); #用装饰过的新类创建对象;

B、目标有参数

#装饰器无参数:

class decorator:

    def __init__(self, cls): #在装饰器的构造函数中传递被装饰类的对象;

        self.cls = cls;

        self.__name__ = cls.__name__; #保证被装饰之后类的名字不变;

        pass;

    #目标有参数:

    def __call__(self, *args, **kwargs): #在__call__()函数中接受callback对象(原始目标函数对象)的所有参数(任意参数);

        print "装饰前的类名: %s" % self.cls.__name__;

        print "enter {func}()".format(func = self.cls.__name__);

        objCls = self.cls(*args, **kwargs);  #调用原始类的构造函数,传递任意参数;

        print "leave {func}()".format(func = self.cls.__name__);

        return objCls; #返回新的目标类对象;

@decorator #装饰器无参数;

class target0:

    def __init__(self): #目标无参数;

        print "装饰后的类名: %s" % target0.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator #装饰器无参数;

class target1:

    def __init__(self, arg1, arg2): #目标有参数;

        self.arg1 = arg1;

        self.arg2 = arg2;

        print "arg1 = ", self.arg1, ", arg2 = ", self.arg2;

        print "装饰后的类名: %s" % target1.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator #装饰器无参数;

class target2:

    def __init__(self, arg1): #目标有参数;

        self.arg1 = arg1;

        print "arg1 = ", self.arg1;

        print "装饰后的类名: %s" % target2.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t1 = target0();     #用装饰过的新类创建对象;

t1.echo("AAAAAAAA");

t2 = target1(6, 8); #用装饰过的新类创建对象;

t2.echo("BBBBBBBB");

t3 = target2(9);    #用装饰过的新类创建对象;

t3.echo("CCCCCCCC");

(2)、装饰器有参数

A、目标无参数

#装饰器有参数:

class decorator:

    def __init__(self, name = 'INFO'): #在装饰器的构造函数中传递装饰器类需要的参数;

        self.name = name;

        pass;

    #目标无参数:

    def __call__(self, cls): #在__call__()函数中接受callback对象(原始目标函数对象)作为参数;

        def wrapper(): #内部闭包函数,给目标类增加额外的功能(没有参数);

            print "装饰前的类名: %s" % cls.__name__;

            print "[{name}] enter {func}()".format(name = self.name, func = cls.__name__);

            objCls = cls();  #调用原始类的构造函数(没有参数);

            print "[{name}] leave {func}()".format(name = self.name, func = cls.__name__);

            return objCls;

        return wrapper; #返回新的目标函数对象;

@decorator()            #装饰器有参数;

class target0:

    def __init__(self): #目标无参数;

        print "装饰后的类名: %s" % target0.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator("DEBUG")     #装饰器有参数;

class target1:

    def __init__(self): #目标无参数;

        print "装饰后的类名: %s" % target1.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator(name = "SYSTEM") #装饰器有参数;

class target2:

    def __init__(self):     #目标无参数;

        print "装饰后的类名: %s" % target2.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t1 = target0(); #用装饰过的新类创建对象;

t1.echo("AAAAAAAA");

t2 = target1(); #用装饰过的新类创建对象;

t2.echo("BBBBBBBB");

t3 = target2(); #用装饰过的新类创建对象;

t3.echo("CCCCCCCC");

B、目标有参数

#装饰器有参数:

class decorator:

    def __init__(self, name = 'INFO'): #在装饰器的构造函数中传递装饰器类需要的参数;

        self.name = name;

        pass;

    #目标有参数:

    def __call__(self, cls): #在__call__()函数中接受callback对象(原始目标函数对象)作为参数;

        def wrapper(*args, **kwargs): #内部闭包函数,给目标类增加额外的功能(任意参数);

            print "装饰前的类名: %s" % cls.__name__;

            print "[{name}] enter {func}()".format(name = self.name, func = cls.__name__);

            objCls = cls(*args, **kwargs);  #调用原始类的构造函数,传递任意参数;

            print "[{name}] leave {func}()".format(name = self.name, func = cls.__name__);

            return objCls;

        return wrapper; #返回新的目标函数对象;

@decorator()            #装饰器有参数;

class target0:

    def __init__(self): #目标无参数;

        print "装饰后的类名: %s" % target0.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator("DEBUG") #装饰器有参数;

class target1:

    def __init__(self, arg1, arg2): #目标有参数;

        self.arg1 = arg1;

        self.arg2 = arg2;

        print "arg1 = ", self.arg1, ", arg2 = ", self.arg2;

        print "装饰后的类名: %s" % target1.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

@decorator(name = "SYSTEM") #装饰器有参数;

class target2:

    def __init__(self, arg1): #目标有参数;

        self.arg1 = arg1;

        print "arg1 = ", self.arg1;

        print "装饰后的类名: %s" % target2.__name__;

        pass;

    def echo(self, msg):

        print "echo: ", msg;

        pass;

t1 = target0();     #用装饰过的新类创建对象;

t1.echo("AAAAAAAA");

t2 = target1(6, 8);   #用装饰过的新类创建对象;

t2.echo("BBBBBBBB");

t3 = target2(9);    #用装饰过的新类创建对象;

t3.echo("CCCCCCCC");

【备注】

针对装饰器类用于装饰函数的情况,装饰器类还有如下写法:把内嵌的闭包函数定义成装饰器类的成员函数;
例如:

#装饰器有参数:

class decorator:

    def __init__(self, name = 'INFO'): #在装饰器的构造函数中传递装饰器类需要的参数;

        self.name = name;

        pass;

    #目标有参数:

    def __call__(self, callback): #在__call__()函数中接受callback对象(原始目标函数对象)作为参数;

        self.callback = callback;

        return self.wrapper; #返回新的目标函数对象(闭包函数对象);

    #原来的闭包函数被定义为成员函数:

    def wrapper(*args, **kwargs): #内部闭包函数,给目标函数增加额外的功能(任意参数);

        print "装饰后的函数名: %s" % callback.__name__;

        print "[{name}] enter {func}()".format(name = self.name, func = callback.__name__);

        result = self.callback(*args, **kwargs);  #调用原始目标函数,传递任意参数;

        print "[{name}] leave {func}()".format(name = self.name, func = callback.__name__);

        return result;

【总结】

[1] @decorator后面不带括号时(也即装饰器无参数时),效果就相当于先定义func或cls,而后执行赋值操作func=decorator(func)或cls=decorator(cls);
[2] @decorator后面带括号时(也即装饰器有参数时),效果就相当于先定义func或cls,而后执行赋值操作 func=decorator(decoratorArgs)(func)或cls=decorator(decoratorArgs)(cls);
[3] 如上将func或cls重新赋值后,此时的func或cls也不再是原来定义时的func或cls,而是一个可执行体,你只需要传入参数就可调用,func(args)=>返回值或者输出,cls(args)=>object of cls;
[4] 最后通过赋值返回的执行体是多样的,可以是闭包,也可以是外部函数;当被装饰的是一个类时,还可以是类内部方法,函数;
[5] 另外要想真正了解装饰器,一定要了解func.func_code.co_varnames,func.func_defaults,通过它们你可以以func的定义之外,还原func的参数列表;另外关键字参数是因为调用而出现的,而不是因为func的定义,func的定义中的用等号连接的只是有默认值的参数,它们并不一定会成为关键字参数,因为你仍然可以按照位置来传递它们;

【转载】

https://www.zybuluo.com/zengxiankui/note/790708

Python 装饰器(Decorators) 超详细分类实例的更多相关文章

使用python装饰器计算函数运行时间的实例
使用python装饰器计算函数运行时间的实例装饰器在python里面有很重要的作用, 如果能够熟练使用,将会大大的提高工作效率今天就来见识一下 python 装饰器,到底是怎么工作的. 本文主要是 ...
【低门槛手把手】python 装饰器(Decorators)原理说明
本文目的是由浅入深地介绍python装饰器原理装饰器(Decorators)是 Python 的一个重要部分其功能是,在不修改原函数(类)定义代码的情况下,增加新的功能为了理解和实现装饰器,我们 ...
Python装饰器(Decorators )
http://book.pythontips.com/en/latest/decorators.html 在<Built-in Functions(3.6)>和<Python上下文管 ...
Python装饰器Decorators
def hi(name="yasoob"): return "hi " + name print(hi()) # 我们甚至可以将一个函数赋值给一个变量,比如 g ...
python装饰器的详细解析
什么是装饰器? python装饰器(fuctional decorators)就是用于拓展原来函数功能的一种函数,目的是在不改变原函数名(或类名)的情况下,给函数增加新的功能. 这个函数的特殊之处在于 ...
关于python装饰器（Decorators）最底层理解的一句话
一个decorator只是一个带有一个函数作为参数并返回一个替换函数的闭包. http://www.xxx.com/html/2016/pythonhexinbiancheng_0718/1044.h ...
python -- 装饰器的高级应用
装饰器和装饰器模式装饰器模式是面向对象的一种设计模式,支持将行为动态增加到已经存在的对象上.当装饰一个对象的时候,就表示独立与其他类实例对象,为该对象扩展了新的功能. python的装饰器不是装饰器模 ...
Python 装饰器入门(上)
翻译前想说的话: 这是一篇介绍python装饰器的文章,对比之前看到的类似介绍装饰器的文章,个人认为无人可出其右,文章由浅到深,由函数介绍到装饰器的高级应用,每个介绍必有例子说明.文章太长,看完原文后 ...
Python 装饰器学习心得
最近打算重新开始记录自己的学习过程,于是就捡起被自己废弃了一年多的博客.这篇学习笔记主要是记录近来看的有关Python装饰器的东西. 0. 什么是装饰器? 本质上来说,装饰器其实就是一个特殊功能的函数 ...

随机推荐

你读过的最好的 C++ 开源代码是什么？
LevelDb LevelDb是谷歌两位大神级别的工程师发起的开源项目,简而言之,LevelDb是能够处理十亿级别规模Key-Value型数据持久性存储的C++ 程序库.链接:google/level ...
前端开发神一样的工具chrome调试技巧
前端开发神一样的工具chrome调试技巧文章来自 Colin-UED // 与您分享前端开发知识主页 Javascript HTML CSS NodeJs User Experience FE ...
504 Gateway Time-out ( Nginx + PHP ) 解决小计
问题最近有个项目,运算量比较大,服务器经常报 504 Gateway Time-out 解决方案 fastcgi_connect_timeout 默认值是 60 第一次尝试修改为 120 ,仍然报5 ...
Tomcat配置https加密连接
配置https安全连接(ssl加密连接) https连接需要用到数字证书与数字签名(MD5算法),网站https连接首先需要申请数字证书,配置加密连接器,浏览器安装证书. 证书运用到RSA技术,RSA ...
ELK日志分析
1. 为什么用到ELK 一般我们需要进行日志分析场景:直接在日志文件中 grep.awk 就可以获取自己想要的信息.但是规模较大的场景中,此方法效率低下,面临问题包括日志量太大如何归档.文本搜索太慢怎 ...
2019年牛客多校第三场 F题Planting Trees(单调队列)
题目链接传送门题意给你一个\(n\times n\)的矩形,要你求出一个面积最大的矩形使得这个矩形内的最大值减最小值小于等于\(M\). 思路单调队列滚动窗口. 比赛的时候我的想法是先枚举长度 ...
洛谷P2216 理想的正方形（单调队列）
洛谷P2216 理想的正方形题目链接思路: 直接暴力显然不可行,可以发现每一个矩形向右边扩展时是一列一列增加,于是可以想到单调队列,用数组来维护当前每列的最大值.因为行也有限制,所以还要用一个单调 ...
java abstractQueue
pve配置
U盘安装推荐使用https://rufus.ie/ 刻录到U盘 (注意:以 DD 镜像模式写入) 关闭订阅提醒将if(data.status!=='Active')替换为if(false) se ...
项目Beta冲刺（团队）——用户试用调查报告
项目Beta冲刺(团队)--用户试用调查报告格式描述课程名称:软件工程1916|W(福州大学) 作业要求:项目Beta冲刺(团队) 团队名称:为了交项目干杯作业目标:针对相应版本展开用户试用,完 ...

Python 装饰器(Decorators) 超详细分类实例

Python装饰器分类

装饰器函数

目标对象是函数

(1)、装饰器无参数

A、目标无参数

B、目标有参数

(2)、装饰器有参数

A、目标无参数

B、目标有参数

目标对象是类

(1)、装饰器无参数

A、目标无参数

B、目标有参数

(2)、装饰器有参数

A、目标无参数

B、目标有参数

装饰器类

目标对象是函数

(1)、装饰器无参数

A、目标无参数

B、目标有参数

(2)、装饰器有参数

A、目标无参数

B、目标有参数

目标对象是类

(1)、装饰器无参数

A、目标无参数

B、目标有参数

(2)、装饰器有参数

A、目标无参数

B、目标有参数

【备注】

【总结】

【转载】

Python 装饰器(Decorators) 超详细分类实例的更多相关文章

随机推荐

热门专题