装饰器python的通俗理解,python装饰器--原来如此简单
目录1。装饰者是函数1.1装饰对象也是函数1.1.1装饰者无参数，装饰对象无参数1.1.2装饰者无参数，装饰对象有参数1.1.3装饰者有参数，装饰对象无参数1.1.4装饰者有参数，装饰对象有参数1.2装饰对象是类1.2.1装饰者无参数，装饰类无参数1.2.2装饰者无参数，装饰类有参数1.2.3装饰者有参数， 装饰类没有参数1.2.4装饰者有参数，装饰类有参数1.3装饰对象是方法1.3.1装饰者没有参数，方法1.3.2装饰者没有参数，方法1.3.3装饰者有参数，方法1.2.4装饰者有参数，装饰类中的方法有参数2 . 装饰者是类2.1装饰对象是函数2.1.1装饰者没有参数，装饰对象没有参数2.1.2装饰者没有参数，装饰对象有参数2.1.3装饰者有参数，装饰对象没有参数2.1.4装饰者有参数，装饰对象有参数2.2装饰对象是类2.2.1装饰者没有参数，装饰类没有参数2.2.2装饰者没有参数2.2装饰者没有参数，装饰类有参数2.2.3装饰者有参数，装饰类没有参数2.2.4装饰者装饰类有参数2.3装饰对象是方法2.3.1装饰者没有参数，方法2.3.2装饰者没有参数，方法2.3.3装饰者有参数，方法2.3.3装饰者有参数，方法2.3.4装饰者有参数，装饰类中的方法有参数1。 装饰者是一个函数1.1装饰者是一个函数。当被装饰对象是一个函数时，装饰器的作用是增强被装饰对象的功能。其思想是切面编程的思想，即在不破坏被修饰函数原有的函数实现的情况下，在被修饰对象的函数前后做一些额外的处理。主要有以下几种情况：
1.1.1装饰器没有参数，被装饰对象也没有参数def decorator(func):
def _decorator():
打印(函数前.)
函数()
打印(函数后.)
返回_装饰者
@装饰者
定义函数():
print(in func(). )
if __name__==__main__ :
func()的执行结果是：
功能前.
函数中的().
功能后.1.1.2 Decorator没有参数，被修饰对象有参数def decorator(func):
def _decorator(*args，**kwargs):
打印(在{name}之前).format(name=func。__name__))
func(*args，**kwargs)
打印(在{姓名}之后.。format(name=func。__name__))
返回_装饰者
@装饰者
定义函数1():
print(in func1(). )
@装饰者
定义函数2(a，b):
print(in func2(). )
print(a={a}，b={b})。格式(a=a，b=b))
@装饰者
def func3(a，b，c=10):
print(in func3(). )
print(a={a}，b={b})。格式(a=a，b=b))
print(c={c})。格式(c=c))
if __name__==__main__ :
func1()
函数2(1，2)
func3(1，2，c=100)的运行结果为：
func1之前.
在func1()中.
func1之后.
func2之前.
在函数2中().
a=1，b=2
func2之后.
func3之前.
在func3()中.
a=1，b=2
c=100
func3之后.1.1.3装饰器有参数，被装饰对象没有参数定义包装器(名称):
定义装饰器(函数):
def _decorator():
print(在{name}之前，decorator param是{param} 。format(name=func。__name__，param=name))
打印(在{name}之前).format(name=func。__name__))
函数()
打印(在{姓名}之后.。format(name=func。__name__))
返回_装饰者
返回装饰者
@wrapper(name=hello world )
定义函数1():
print(in func1(). )
if __name__==__main__ :
func1()的运行结果是：
在func1之前，装饰参数是hello world
func1之前.
在func1()中.
func1之后.1.1.4 装饰器有参数，被装饰器对象有参数定义包装（名称):
定义装饰器（函数):
def _decorator(*args，**kwargs):
打印(在{姓名}之前，装饰参数是{param} .format(name=func .__name__，param=name))
打印(在{姓名}之前).format(name=func .__name__))
func(*args，**kwargs)
打印(在{姓名}之后.。format(name=func .__name__))
返回_装饰者
返回装饰者
@wrapper(name=hello world )
定义函数1():
print(in func1(). )
@wrapper(name=hello world )
定义函数2(a，b):
print(in func2(). )
打印( a={a}，b={b}).格式(a=a，b=b))
@wrapper(name=hello world )
def func3(a，b，c=10):
打印( in func3().)
打印( a={a}，b={b}).格式(a=a，b=b))
打印( c={c}).格式(c=c))
if __name__==__main__ :
func1()
函数2(1,2)
func3(1，2，c=100)运行结果如下：
在func1之前，装饰参数是你好世界
func1之前.
在func1()中.
func1之后.
在功能2之前，装饰参数是你好世界
功能2之前.
在函数2中().
a=1，b=2
功能2之后.
在func3之前，装饰参数是你好世界
func3之前.
在func3()中.
a=1，b=2
c=100
func3之后.1.2 被装饰器对象是类被装饰器对象为类时，装饰器的作用是类在初始化的时候做功能增强，即可以在类初始化之前或者之后做一些功能增强，所以下面所说的被装饰对象有无参数是针对类的初始化函数__init__有无参数而言的，主要有以下几种情况：
1.2.1 装饰器无参数，被装饰类无参数定义装饰器(cls):
def _decorator():
打印(在类{姓名}初始化之前.。格式(name=cls .__name__))
obj=cls()
打印( class { name } init之后.。格式(name=cls .__name__))
返回对象
返回_装饰者
@装饰者
类测试（对象):
def __init__(self):
打印(在类{姓名}的初始化函数中.。格式（名称=测试. __姓名_ _))
定义函数（自身):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
if __name__==__main__ :
测试=测试()
test.func()运行结果如下：
课前测试初始化.
在class _装饰者初始化函数中.
课后测试初始化.
在class _decorator func()1.2.2中装饰器无参数，被装饰类有参数定义装饰器(cls):
def _decorator(*args，**kwargs):
打印(在类{姓名}初始化之前.。格式(name=cls .__name__))
obj=cls(*args，**kwargs)
打印( class { name } init之后.。格式(name=cls .__name__))
返回对象
返回_装饰者
@装饰者
类测试（对象):
def __init__(self，a，b=10):
打印(在类{姓名}的初始化函数中.。格式（名称=测试. __姓名_ _))
打印( a={a}，b={b}).格式(a=a，b=b))
定义函数（自身):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
if __name__==__main__ :
test=Test(2，20)
test.func()执行结果如下：
课前测试初始化.
在class _装饰者初始化函数中.
a=2，b=20
课后测试初始化.
在class _decorator func()1.2.3中装饰器有参数，被装饰类无参数定义包装器(name=hello world ):
定义装饰器(cls):
def _decorator():
打印(在类{姓名}初始化之前.。格式(name=cls .__name__))
obj=cls()
打印( class { name } init之后.。格式(name=cls .__name__))
返回对象
返回_装饰者
返回装饰者
@wrapper(hello world )
类测试（对象):
def __init__(self):
打印(在类{姓名}的初始化函数中.。格式（名称=测试. __姓名_ _))
定义函数（自身):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
if __name__==__main__ :
测试=测试()
test.func()执行结果如下：
课前测试初始化.
在class _装饰者初始化函数中.
课后测试初始化.
在class _decorator func()1.2.4中装饰器有参数，被装饰类有参数定义包装器(name=hello world ):
定义装饰器(cls):
def _decorator(*args，**kwargs):
打印(在类{姓名}初始化之前.。格式(name=cls .__name__))
obj=cls(*args，**kwargs)
打印( class { name } init之后.。格式(name=cls .__name__))
返回对象
返回_装饰者
返回装饰者
@wrapper(hello world )
类测试（对象):
def __init__(self，a，b=10):
打印(在类{姓名}的初始化函数中.。格式（名称=测试. __姓名_ _))
打印( a={a} b={b}).格式(a=a，b=b))
定义函数（自身):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
if __name__==__main__ :
测试=测试(2，b=20)
test.func()运行结果如下：
课前测试初始化.
在class _装饰者初始化函数中.
a=2 b=20
课后测试初始化.
在class _decorator func()1.3中被装饰对象是类中的方法当被装饰对象是类中的方法时，装饰器的作用是对类中的方法进行功能加强，此时需要注意的是装饰器的内层函数需要增加一个自己形参
1.3.1 装饰器无参数，被装饰类中的方法无参数定义装饰器（函数):
def _decorator(self):
打印(在方法{姓名}之前).format(name=func .__name__))
obj=func(self)
打印(在方法{姓名}之后).format(name=func .__name__))
返回对象
返回_装饰者
类测试（对象):
def __init__(self，a=1，b=10):
self.a=a
self.b=b
@装饰者
定义函数（自身):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
打印( a={a} b={b}).格式(a=self.a，b=self.b))
if __name__==__main__ :
测试=测试()
test.func()执行结果如下：
方法函数之前.
类内测试函数()
a=1 b=10
方法函数之后.1.3.2 装饰器无参数，被装饰类中的方法有参数（函数):
def _decorator(self，*args，**kwargs):
打印(在方法{姓名}之前).format(name=func .__name__))
obj=func(self，*args，**kwargs)
打印(在方法{姓名}之后).format(name=func .__name__))
返回对象
返回_装饰者
类测试（对象):
def __init__(self，a=1，b=10):
self.a=a
self.b=b
@装饰者
def func(self，c，d=20):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
打印( a={a} b={b}).格式(a=self.a，b=self.b))
打印( c={c} d={d}).格式(c=c，d=d))
if __name__==__main__ :
测试=测试()
test.func(2，d=20)执行结果如下：
方法函数之前.
类内测试函数()
a=1 b=10
c=2 d=20
方法函数之后.1.3.3 装饰器有参数，被装饰类中的方法无参数定义包装器(name=hello world ):
定义装饰器（函数):
def _decorator(self):
打印(在方法{姓名}之前).format(name=func .__name__))
print(name={name}).格式(name=name))
obj=func(self)
打印(在方法{姓名}之后).format(name=func .__name__))
返回对象
返回_装饰者
返回装饰者
类测试（对象):
def __init__(self，a=1，b=10):
self.a=a
self.b=b
@wrapper(name=Test.func )
定义函数（自身):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
打印( a={a} b={b}).格式(a=self.a，b=self.b))
if __name__==__main__ :
测试=测试()
test.func()执行结果如下：
方法函数之前.
name=Test.func
类内测试函数()
a=1 b=10
方法函数之后.1.2.4 装饰器有参数，被装饰类中的方法有参数定义包装器(name=hello world ):
定义装饰器（函数):
def _decorator(self，*args，**kwargs):
打印(在metthod { name }之前).format(name=func .__name__))
print(name={name}).格式(name=name))
obj=func(self，*args，**kwargs)
打印(在方法{姓名}之后).format(name=func .__name__))
返回对象
返回_装饰者
返回装饰者
类测试（对象):
def __init__(self，a=1，b=10):
self.a=a
self.b=b
@wrapper(name=Test.func )
def func(self，c，d=20):
print(in class {name} func()).格式（名称=测试. __姓名_ _))
打印( a={a} b={b}).格式(a=self.a，b=self.b))
打印( c={c} d={d}).格式(c=c，d=d))
if __name__==__main__ :
测试=测试()
test.func(2，d=20)执行结果如下：
方法函数之前.
name=Test.func
类内测试函数()
a=1 b=10
c=2 d=20
方法函数之后.二、装饰器是类2.1 被装饰对象是函数装饰器是类，被装饰对象是函数的时候，是通过装饰器类初始化的时候将被装饰对象函数传递给装饰器类，然后通过自动调用装饰器类中的__呼叫_ _函数实现对被装饰对象的前后处理，即在这种情况下，只需要在__呼叫_ _函数中编写在调用被装饰对象前后进行操作的代码即可
2.1.1 装饰器无参数，被装饰对象无参数类装饰器（对象):
def __init__(self，func):
self.func=func
def __call__(self):
print(before func {func}(). 。format(func=self.func.__name__))
result=self.func()
print(after func {func}(). 。format(func=self.func.__name__))
回送结果
@装饰者
定义函数():
print(in func func(). )
if __name__==__main__ :
函数()执行结果如下：
在func func()之前.
in func func().
在func func()之后.2.1.2 装饰器无参数，被装饰对象有参数类装饰器（对象):
def __init__(self，func):
self.func=func
def __call__(self，*args，**kwargs):
print(before func {func}(). 。format(func=self.func.__name__))
result=self.func(*args，**kwargs)
print(after func {func}(). 。format(func=self.func.__name__))
回送结果
@装饰者
def func(a，b=10):
print(in func func(). )
打印( a={a} b={b}).格式(a=a，b=b))
if __name__==__main__ :
func(2，b=20)执行结果如下：
在func func()之前.
in func func().
a=2 b=20
在func func()之后.2.1.3 装饰器有参数，被装饰对象无参数（对象):
def __init__(self，name=hello world ):
self.name=name
def __call__(self，func):
极好的包装():
print(before func {func}(). 。format(func=func .__name__))
print(name={name}).格式(name=self.name))
result=func()
print(after func {func}(). 。format(func=func .__name__))
回送结果
返回包装
@decorator()
定义函数1():
print(in func func2(). )
@decorator(func2_decorator )
定义函数2():
print(in func func2(). )
@ decorator(name= func 3 _ decorator )
定义函数3():
print(in func func3(). )
if __name__==__main__ :
func1()
函数2()
func3()执行结果如下：
func func1()之前.
你好，世界
在函数函数2()中.
在func func1()之后.
函数函数2()之前.
name=func2_decorator
在函数函数2()中.
在函数函数2()之后.
func func3()之前.
name=func3_decorator
在func func3()中.
在func func3()之后.2.1.4 装饰器有参数，被装饰器对象有参数（对象):
def __init__(self，name=hello world ):
self.name=name
def __call__(self，func):
极好的包装(*args，**kwargs):
print(before func {func}(). 。format(func=func .__name__))
print(name={name}).格式(name=self.name))
result=func(*args，**kwargs)
print(after func {func}(). 。format(func=func .__name__))
回送结果
返回包装
@decorator()
定义函数1():
print(in func func2(). )
@decorator(func2_decorator )
定义功能2(a):
print(in func func2(). )
打印( a={a}).格式(a=a))
@ decorator(name= func 3 _ decorator )
def func3(a，b=10):
print(in func func3(). )
打印( a={a}，b={b}).格式(a=a，b=b))
if __name__==__main__ :
func1()
函数2(10)
func3(2，b=20)执行结果如下：
func func1()之前.
你好，世界
在函数函数2()中.
在func func1()之后.
函数函数2()之前.
name=func2_decorator
在函数函数2()中.
a=10
在函数函数2()之后.
func func3()之前.
name=func3_decorator
在func func3()中.
a=2，b=20
在func func3()之后.2.2 被装饰器对象是类同样，当被装饰对象是类是，装饰器的作用是对被装饰类的初始化方法进行功能加强，而装饰器则是以类的形式定义的
2.2.1 装饰器无参数，被装饰类无参数类装饰器（对象):
def __init__(self，cls):
self.cls=cls
def __call__(self):
打印(在初始化clsss {cls}之前).格式(cls=self.cls.__name__))
obj=self.cls()
打印(在初始化类{cls}之后).格式(cls=self.cls.__name__))
返回对象
@装饰者
类测试():
def __init__(self):
打印(在测试类__init__ func中.)
定义测试（自我):
打印(在测试类测试函数中.)
if __name__==__main__ :
t=测试()
t。测试()执行结果如下：
初始化不管怎样的测试前.
在测试类__init__ func中.
初始化类测试后.
测试类中的测试函数.2.2.2 装饰器无参数，被装饰类有参数类装饰器（对象):
def __init__(self，cls):
self.cls=cls
def __call__(self，*args，**kwargs):
打印(在初始化clsss {cls}之前).格式(cls=self.cls.__name__))
obj=self.cls(*args，**kwargs)
打印(在初始化类{cls}之后).格式(cls=self.cls.__name__))
返回对象
@装饰者
类测试():
def __init__(self，a，b=10):
打印(在测试类__init__ func中.)
打印( a={a} b={b}).格式(a=a，b=b))
定义测试（自我):
打印(在测试类测试函数中.)
if __name__==__main__ :
t=测试(2，b=20)
t。测试()执行结果如下：
初始化不管怎样的测试前.
在测试类__init__ func中.
a=2 b=20
初始化类测试后.
测试类中的测试函数.2.2.3 装饰器有参数，被装饰类无参数类装饰器（对象):
def __init__(self，name=hello world ):
self.name=name
def __call__(self，cls):
极好的包装():
打印(在初始化类{cls}之前).格式(cls=cls .__name__))
obj=cls()
打印(在初始化类{cls}之后).格式(cls=cls .__name__))
返回对象
返回包装
@decorator(name=Test Class )
类测试():
def __init__(self):
打印(在测试类__init__ func中.)
定义测试（自我):
打印(在测试类测试函数中.)
if __name__==__main__ :
t=测试()
t。测试()执行结果如下：
初始化类测试之前.
在测试类__init__ func中.
初始化类测试后.
测试类中的测试函数.2.2.4 装饰器有参数，被装饰类有参数类装饰器（对象):
def __init__(self，name=hello world ):
self.name=name
def __call__(self，cls):
极好的包装(*args，**kwargs):
打印(在初始化类{cls}之前).格式(cls=cls .__name__))
obj=cls(*args，**kwargs)
打印(在初始化类{cls}之后).格式(cls=cls .__name__))
返回对象
返回包装
@decorator(name=Test Class )
类测试():
def __init__(self，a，b=10):
打印(在测试类__init__ func中.)
打印( a={a}，b={b}).格式(a=a，b=b))
定义测试（自我):
打印(在测试类测试函数中.)
if __name__==__main__ :
t=测试(2，b=20)
t。测试()执行结果如下：
初始化类测试之前.
在测试类__init__ func中.
a=2，b=20
初始化类测试后.
测试类中的测试函数.2.3 被装饰对象是类中的方法2.3.1 装饰器无参数，被装饰类中的方法无参数类装饰器（对象):
def __init__(self，func):
self.func=func
def __call__(self):
print(before func {func})。 。format(func=self.func.__name__))
结果=self.func(自我)
print(after func {func})。 。format(func=self.func.__name__))
返回结果
类测试():
def __init__(self):
打印(在测试类__init__ func中.)
@装饰者
定义测试（自我):
打印(在测试类测试函数中.)
if __name__==__main__ :
t=测试()
t。测试()执行结果如下：
在测试类__init__ func中.
功能测试前.
测试类中的测试函数.
功能测试后.2.3.2 装饰器无参数，被装饰类中的方法有参数类装饰器（对象):
def __init__(self，func):
self.func=func
def __call__(self，*args，**kwargs):
print(before func {func})。 。format(func=self.func.__name__))
results=self.func(self，*args，**kwargs)
print(after func {func})。 。format(func=self.func.__name__))
返回结果
类测试():
def __init__(self):
打印(在测试类__init__ func中.)
@装饰者
定义测试（自我，a，b=10):
打印(在测试类测试函数中.)
打印( a={a} b={b}).格式(a=a，b=b))
if __name__==__main__ :
t=测试()
t检验(2，b=20)执行结果如下：
在测试类__init__ func中.
功能测试前.
测试类中的测试函数.
a=2 b=20
功能测试后.2.3.3 装饰器有参数，被装饰类中的方法无参数类装饰器（对象):
def __init__(self，name=hello world ):
self.name=name
def __call__(self，func):
定义包装（自身):
print(before func {func})。 。format(func=func .__name__))
结果=功能（自我)
print(after func {func})。 。format(func=func .__name__))
返回结果
返回包装
类测试():
def __init__(self):
打印(在测试类__init__ func中.)
@decorator(name=Test_test )
定义测试（自我):
打印(在测试类测试函数中.)
if __name__==__main__ :
t=测试()
t。测试()执行结果如下：
在测试类__init__ func中.
功能测试前.
测试类中的测试函数.
功能测试后.2.3.4 装饰器有参数，被装饰类中的方法有参数类装饰器（对象):
def __init__(self，name=hello world ):
self.name=name
def __call__(self，func):
定义包装器(self，*args，**kwargs):
print(before func {func})。 。format(func=func .__name__))
results=func(self，*args，**kwargs)
print(after func {func})。 。format(func=func .__name__))
返回结果
返回包装
类测试():
def __init__(self):
打印(在测试类__init__ func中.)
@decorator(name=Test_test )
定义测试（自我，a，b=10):
打印(在测试类测试函数中.)
打印( a={a}，b={b}).格式(a=a，b=b))
if __name__==__main__ :
t=测试()
t检验(2，b=20)执行结果如下：
在测试类__init__ func中.
功能测试前.
测试类中的测试函数.
a=2，b=20
功能测试后.
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。