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

最新推荐文章于 2023-11-14 10:51:51 发布
最新推荐文章于 2023-11-14 10:51:51 发布
阅读量122 收藏
点赞数
文章标签： python 装饰器分类

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的定义中的用等号连接的只是有默认值的参数,它们并不一定会成为关键字参数,因为你仍然可以按照位置来传递它们;

【转载】

weixin_39667080
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python装饰器的实现和万能装饰器
weixin_43790276的博客
06-01 5594
Python装饰器的实现和万能装饰器 在Python中，装饰器是在不改变已有函数的代码的前提下，给函数增加新的功能的一种函数。 装饰器接收一个函数作为参数，返回值也是一个函数。 在Python中，实现装饰器的方式叫做闭包。 一、闭包的实现 闭包是指函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。 闭包的使用，可以隐藏内部函数的工作细节，只给外部...
python decorator for class
Neil的博客
12-15 369
1.描述 把类做成装饰器，暂时没感觉到有什么用。函数全部在@时就已经执行完了，main函数中调用函数显示未定义，只能打印@时函数执行完的结果 2.代码 # -*- coding: utf-8 -*- class First(object): print(' First begin...') def __init__(self, num, name): ...
python学习-装饰器（decorator）
u013824564的博客
06-08 362
文章目录装饰器普通装饰器装饰器带参数类装饰器类方法装饰器 装饰器 装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。 普通装饰器 个人理解普通装饰器和直接调用函数没什么区别，就是相当于函数的调用。 def test1(x): return x ** 2 def test2(x): return x * 3 + x / 2 test1(6) test2(8) def func(f): def fNew(x):
3分钟带你了解Python装饰器（Decorators）离成为大佬又近了一步
最新发布
aobulaien001的博客
11-14 64
装饰器（Decorators）是Python中一种强大的编程工具，它允许您在不修改被装饰函数源代码的情况下，增加、修改或扩展函数的功能。装饰器本质上是一个函数，它接受一个函数作为输入，并返回一个新的函数。装饰器在实际开发中常用于代码重用、日志记录、性能分析、权限检查等方面。
python class类和装饰器decorator
xcs166357的博客
02-24 385
深入了解Python装饰器的高级用法
12-17
https://www.codementor.io/python/tutorial/advanced-use-python-decorators-class-function 介绍 我写这篇文章的主要目的是介绍装饰器的高级用法。如果你对装饰器知之甚少，或者对本文讲到的知识点易混淆。我建议...
Python高級编程_python进阶_python高级编程_
10-03
2. **装饰器（Decorators）**：装饰器是Python中的一个强大工具，可以修改或增强函数、类的行为，而不改变其原始代码。学习如何创建和使用装饰器可以提升代码的灵活性和重用性。 3. **上下文管理器（Context ...
memorised:用于 Python 的 memcache memoization 装饰器和实用程序
06-17
memorised是一个 python 模块，包含方便的python-memcached装饰器和实用程序。 特别是memorise装饰器允许您快速简单地将 memcache 缓存添加到任何函数或方法。 安装 使用 pip 安装memorised ： pip install ...
python 装饰模式（示例）
11-24
在Python中，装饰器（decorators）是实现装饰模式的一种常见方式，它们为函数或类提供了方便的扩展机制。让我们深入探讨Python中的装饰模式及其应用。 装饰模式的核心在于它允许我们在不修改原有对象的基础上，通过...
Python库 | free_properties-0.2.4.tar.gz
03-07
通过使用`free_properties`的装饰器，开发者可以轻松地声明一个类的属性，这些属性在实例化后可以被自由地读写，而无需编写繁琐的访问器方法。 例如，假设我们有一个类`Person`，我们希望添加一个`age`属性，但又不...
各类速查表汇总-Python Decorators
04-10
各类速查表汇总-Python Decorators Decorators 基础命令速查
python中decorator的用法及原理（一）
u013696062的专栏
04-05 2万+
0、 概念 什么叫装饰器，其实也可以叫做包装器。即对于一个既有的函数func(args)，在调用它之前和之后，我们希望都做一些事情，把这个函数包装起来。 python中的装饰器分为两类：函数装饰器和类装饰器。 这里我们先讨论函数装饰器。 1. 不带参数的decorator (1) 基本用法： def decorator1(func): def dec(*args):
[Python入门及进阶笔记]Python-decorator装饰器小结
jishublog
10-27 252
<style> <!-- h1, h2, h3, h4, h5, h6, p, blockquote {margin:0; padding:0} body {font-family:"Helvetica Neue",Helvetica,"Hiragino Sans GB",Arial,sans-serif; font-size:13px; line-he...
Python Decorators入门 （一）
热门推荐
Bruce Eckel 博客中文版
12-22 2万+
Decorators I: Introduction to Python DecoratorsOctober 18, 2008  我预计它会成为Python最重要的几个特性之一。而问题是我见过的所有介绍decorators的文章都很容易让人感到困惑。所以我打算在这里给以纠正以正视听。(本系列文章将录入开源类书籍Python3之模式和用法) Decorators vs.
Python Decorator 3: 嵌套
小胖子吃辣肉面的专栏
04-18 719
@decorator_one @decorator_two def func(): pass 等价于 func = decorator_one(decorator_two(func)) @decorator(arg1, arg2) def func(): pass 等价于 func = decorator(arg1,arg2)(func) 带参数及多
python decorator
kangking2010的专栏
01-07 285
1.常用方法，不带参数def decator(func):    def inner_func(*args):        args = (i * 2 for i in args)        return func(*args)    return inner_func    @decatordef add(a, b, c):    return
《在路上 …》 写代码也需要一点演技 – python2.6 的 class decorator
张沈鹏,在路上 ...
11-21 107
写通用的回复类, 原本打算做成一个独立的基类 class ReplyBase(object):     _REPLY_REALTED_CLS = None                                                                   _REPLY_CLS = None                                    ...
python黑魔法之 “@classmethod” decorator
qq_40489435的博客
02-18 288
最近看了很多关于python内置函数的资料，看到关于classmethod的时候，有点混乱，而且看了别人的分析也有点不太清晰，然后自己写了例子分析了一下，以下就是自己的理解，以及为啥要用这个东西。 class base: tasks = [] # def add_task(self, name): # base.tasks.append(name) @c...
函数装饰器(Decorators)详解 | Python
用途：中英文学习笔记，如有侵权，可评论留言，及时清理；学历：NUS计算机硕士；SYSU地球物理学士
05-31 1637
装饰器(Decorators)是 Python 的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic（Python范儿）。大多数初学者不知道在哪儿使用它们，所以我将要分享下，哪些区域里装饰器可以让你的代码更简洁。 首先，让我们讨论下如何写你自己的装饰器。 这可能是最难掌握的概念之一。我们会每次只讨论一个步骤，这样你能完全理解它。 一切皆对象 def hi(name="yasoob"): return "hi " + name print(hi
Python进阶.pdf
04-11
Python进阶

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值