python 装饰器分类_Python 装饰器(Decorators) 超详细分类实例
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被用作關鍵字參數傳遞(可選參數的特點);
deftarget3(a, b, c):
strNewFunctionName= target3.__name__;print "裝飾后的函數名target = %s" %strNewFunctionName;print "a = %d, b = %d, c = %d" %(a, b, c);pass;#裝飾器有參數:
@decorator('PROCESS') #裝飾目標函數,參數name沒有被用作關鍵字參數傳遞;
deftarget2(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; #返回一級閉包函數對象;
@decoratorclasstarget:def __init__(self): #目標無參數;
strNewClassName = target.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(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; #返回一級閉包函數對象;
@decoratorclasstarget1:def __init__(self, arg): #目標有參數;
self.arg =arg;print "arg =", arg;
strNewClassName= target1.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(self, msg):print "echo:", msg;pass;
@decoratorclasstarget2: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;defecho(self, msg):print "echo:", msg;pass;
@decoratorclasstarget3:def __init__(self): #目標無參數;
strNewClassName = target3.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(self, msg):print "echo:", msg;pass;
t1= target1(123); #用裝飾過的新類創建對象;
t1.echo("1111111111");
t2= target2(456, 789); #用裝飾過的新類創建對象;
t1.echo("2222222222");
t3= target3(); #用裝飾過的新類創建對象;
t3.echo("3333333333");
(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()classtarget1:def __init__(self): #目標無參數;
strNewClassName = target1.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator("DEBUG")classtarget2:def __init__(self): #目標無參數;
strNewClassName = target2.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator(level= "SYSTEM")classtarget3:def __init__(self): #目標無參數;
strNewClassName = target3.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(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()classtarget1:def __init__(self, arg):
self.arg=arg;print "arg =", arg;
strNewClassName= target1.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator('ERROR')classtarget2: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;defecho(self, msg):print "echo:", msg;pass;
@decorator(level= 'WARN')classtarget3:def __init__(self):
strNewClassName= target3.__name__;print "裝飾后的類名: %s" %strNewClassName;pass;defecho(self, msg):print "echo:", msg;pass;
t1= target1(123); #用裝飾過的新類創建對象;
t1.echo("1111111111");
t2= target2(456, 789); #用裝飾過的新類創建對象;
t1.echo("2222222222");
t3= target3(); #用裝飾過的新類創建對象;
t3.echo("3333333333");
裝飾器類
裝飾器本身是一個類,通過構造函數__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__);returnresult;
@decoratordeftarget():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__);returnresult;
@decoratordeftarget0():print "裝飾后的函數名: %s" % target0.__name__;pass;
@decoratordeftarget1(a, b):print "a = %d, b = %d" %(a, b);print "裝飾后的函數名: %s" % target1.__name__;pass;
target0();#調用裝飾過的新函數;
target1(6, 8); #調用裝飾過的新函數;
(2)、裝飾器有參數
A、目標無參數
#裝飾器有參數:
classdecorator: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__);returnresult;return wrapper; #返回新的目標函數對象;
@decorator()deftarget0():print "裝飾后的函數名: %s" % target0.__name__;pass;
@decorator('ERROR')deftarget1():print "裝飾后的函數名: %s" % target1.__name__;pass;
@decorator(name= 'SYSTEM')deftarget2():print "裝飾后的函數名: %s" % target2.__name__;pass;
target0();#調用裝飾過的新函數;
target1(); #調用裝飾過的新函數;
target2(); #調用裝飾過的新函數;
B、目標有參數
#裝飾器有參數:
classdecorator: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__);returnresult;return wrapper; #返回新的目標函數對象;
@decorator()deftarget0():print "裝飾后的函數名: %s" % target0.__name__;pass;
@decorator('ERROR')deftarget1(a):print "裝飾后的函數名: %s" % target1.__name__;print "a = %d" %(a);pass;
@decorator(name= 'SYSTEM')deftarget2(x, y):print "裝飾后的函數名: %s" % target2.__name__;print "x = %d, y = %d" %(x, y);pass;
target0();#調用裝飾過的新函數;
target1(2); #調用裝飾過的新函數;
target2(6, 8); #調用裝飾過的新函數;
目標對象是類
(1)、裝飾器無參數
A、目標無參數
#裝飾器無參數:
classdecorator: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 #裝飾器無參數;
classtarget:def __init__(self): #目標無參數;
print "裝飾后的類名: %s" % target.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
t= target(); #用裝飾過的新類創建對象;
B、目標有參數
#裝飾器無參數:
classdecorator: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 #裝飾器無參數;
classtarget0:def __init__(self): #目標無參數;
print "裝飾后的類名: %s" % target0.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator#裝飾器無參數;
classtarget1:def __init__(self, arg1, arg2): #目標有參數;
self.arg1 =arg1;
self.arg2=arg2;print "arg1 =", self.arg1, ", arg2 =", self.arg2;print "裝飾后的類名: %s" % target1.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator#裝飾器無參數;
classtarget2:def __init__(self, arg1): #目標有參數;
self.arg1 =arg1;print "arg1 =", self.arg1;print "裝飾后的類名: %s" % target2.__name__;pass;defecho(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、目標無參數
#裝飾器有參數:
classdecorator: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__);returnobjCls;return wrapper; #返回新的目標函數對象;
@decorator() #裝飾器有參數;
classtarget0:def __init__(self): #目標無參數;
print "裝飾后的類名: %s" % target0.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator("DEBUG") #裝飾器有參數;
classtarget1:def __init__(self): #目標無參數;
print "裝飾后的類名: %s" % target1.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator(name= "SYSTEM") #裝飾器有參數;
classtarget2:def __init__(self): #目標無參數;
print "裝飾后的類名: %s" % target2.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
t1= target0(); #用裝飾過的新類創建對象;
t1.echo("AAAAAAAA");
t2= target1(); #用裝飾過的新類創建對象;
t2.echo("BBBBBBBB");
t3= target2(); #用裝飾過的新類創建對象;
t3.echo("CCCCCCCC");
B、目標有參數
#裝飾器有參數:
classdecorator: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__);returnobjCls;return wrapper; #返回新的目標函數對象;
@decorator() #裝飾器有參數;
classtarget0:def __init__(self): #目標無參數;
print "裝飾后的類名: %s" % target0.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator("DEBUG") #裝飾器有參數;
classtarget1:def __init__(self, arg1, arg2): #目標有參數;
self.arg1 =arg1;
self.arg2=arg2;print "arg1 =", self.arg1, ", arg2 =", self.arg2;print "裝飾后的類名: %s" % target1.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
@decorator(name= "SYSTEM") #裝飾器有參數;
classtarget2:def __init__(self, arg1): #目標有參數;
self.arg1 =arg1;print "arg1 =", self.arg1;print "裝飾后的類名: %s" % target2.__name__;pass;defecho(self, msg):print "echo:", msg;pass;
t1= target0(); #用裝飾過的新類創建對象;
t1.echo("AAAAAAAA");
t2= target1(6, 8); #用裝飾過的新類創建對象;
t2.echo("BBBBBBBB");
t3= target2(9); #用裝飾過的新類創建對象;
t3.echo("CCCCCCCC");
【備注】
針對裝飾器類用于裝飾函數的情況,裝飾器類還有如下寫法:把內嵌的閉包函數定義成裝飾器類的成員函數;
例如:
#裝飾器有參數:
classdecorator: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的定義中的用等號連接的只是有默認值的參數,它們并不一定會成為關鍵字參數,因為你仍然可以按照位置來傳遞它們;
【轉載】
總結
以上是生活随笔為你收集整理的python 装饰器分类_Python 装饰器(Decorators) 超详细分类实例的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： movs 数据传送指令_PLC中简单好用
- 下一篇： python是谁维护的_Python 库