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) 超详细分类实例的更多相关文章

  1. 使用python装饰器计算函数运行时间的实例

    使用python装饰器计算函数运行时间的实例 装饰器在python里面有很重要的作用, 如果能够熟练使用,将会大大的提高工作效率 今天就来见识一下 python 装饰器,到底是怎么工作的. 本文主要是 ...

  2. 【低门槛 手把手】python 装饰器(Decorators)原理说明

    本文目的是由浅入深地介绍python装饰器原理 装饰器(Decorators)是 Python 的一个重要部分 其功能是,在不修改原函数(类)定义代码的情况下,增加新的功能 为了理解和实现装饰器,我们 ...

  3. Python装饰器(Decorators )

    http://book.pythontips.com/en/latest/decorators.html 在<Built-in Functions(3.6)>和<Python上下文管 ...

  4. Python装饰器Decorators

    def hi(name="yasoob"): return "hi " + name print(hi()) # 我们甚至可以将一个函数赋值给一个变量,比如 g ...

  5. python装饰器的详细解析

    什么是装饰器? python装饰器(fuctional decorators)就是用于拓展原来函数功能的一种函数,目的是在不改变原函数名(或类名)的情况下,给函数增加新的功能. 这个函数的特殊之处在于 ...

  6. 关于python装饰器（Decorators）最底层理解的一句话

    一个decorator只是一个带有一个函数作为参数并返回一个替换函数的闭包. http://www.xxx.com/html/2016/pythonhexinbiancheng_0718/1044.h ...

  7. python -- 装饰器的高级应用

    装饰器和装饰器模式装饰器模式是面向对象的一种设计模式,支持将行为动态增加到已经存在的对象上.当装饰一个对象的时候,就表示独立与其他类实例对象,为该对象扩展了新的功能. python的装饰器不是装饰器模 ...

  8. Python 装饰器入门(上)

    翻译前想说的话: 这是一篇介绍python装饰器的文章,对比之前看到的类似介绍装饰器的文章,个人认为无人可出其右,文章由浅到深,由函数介绍到装饰器的高级应用,每个介绍必有例子说明.文章太长,看完原文后 ...

  9. Python 装饰器学习心得

    最近打算重新开始记录自己的学习过程,于是就捡起被自己废弃了一年多的博客.这篇学习笔记主要是记录近来看的有关Python装饰器的东西. 0. 什么是装饰器? 本质上来说,装饰器其实就是一个特殊功能的函数 ...

随机推荐

  1. 【LeetCode】48. Rotate Image

    Difficulty:medium  More:[目录]LeetCode Java实现 Description https://leetcode.com/problems/rotate-image/ ...

  2. HTTP协议随笔

    代理 代理就是处在客户端和服务端之间的服务器.客户端例如浏览器发送GET请求时,代理服务器接收该请求,并转发该请求至服务所在的服务器.服务器回复的数据和资源在第一时间经过代理服务器,才能回传到浏览器, ...

  3. Python变量问题：命名、类型、赋值

    1.变量问题 1.1变量命名: (1)变量名只能包含字母.数字和下划线.变量名可以字母或下划线开头,但不能以数字开头.例如,name1_,_name1都是合法的,但1name就不行(2)变量名中间不能 ...

  4. Kafka学习笔记之如何永久删除Kafka的Topic

    0x00 问题描述 使用kafka-topics --delete命令删除topic时并没有真正的删除,而是把topic标记为:“marked for deletion”,导致重新创建相同名称的Top ...

  5. Git 管理版本/回退

    参考链接:https://www.liaoxuefeng.com/wiki/896043488029600/896954074659008 Git status命令可以让我们时刻掌握仓库当前的状态,比 ...

  6. python自动备份阿里云数据库binlog

    #coding:utf8from aliyunsdkcore import clientfrom aliyunsdkrds.request.v20140815 import DescribeBacku ...

  7. Date+闭包

    date类: var  time=new.date() get date() 返回一个月中的某一天 get day () 返回一周中的某一天 get fullyear() 对象以四位数返回年份 get ...

  8. 关于Apache安全加固的总结

    在给企业提加固方案的时候,检查服务器安全设置是必不可少的. “最小权限原则”: 当一个黑客在入侵一个网络并拿到webshell的后续就是思考是否需要提权.如果此刻的webshell直接是system或 ...

  9. WPE 过滤器 滤镜 用法

    过滤所有数值匹配的数据包,并修改指定的bit位 打开游戏 打开WPE 附加游戏进程 选项配置 用来配置抓取发送和接收包类型 先抓取发送包,也就是游戏中主动发给服务器的包 点击开始抓包 输入喊话内容 分 ...

  10. win10系统下安装Ubuntu18.04双系统

    1.http://releases.ubuntu.com/18.04/ubuntu-18.04.2-desktop-amd64.iso下载Ubuntu 18.04镜像,准备好一个空的U盘 2.下载ru ...