當前位置：首頁 > 编程语言 > python >内容正文

python

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

發布時間：2024/9/19 python 24 豆豆

生活随笔收集整理的這篇文章主要介紹了 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()用于傳遞目標函數的所有參數;

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 库