函数的装饰器：
（1），被装饰的函数没有返回值：
1 def decorator(func):
2 def wrapper(arg):
3 t1 = time.perf_counter()
4 func(arg)
5 print(time.perf_counter()-t1)
6 return wrapper
7
8 @decorator
9 def func(arg): #没有返回值
10 i = 1
11 while(1):
12 i+=1
13 if i>1000:
14 print(arg)
15 break
16
17
18 if __name__ =="__main__":
19 import time
20 func("I am done")
21
22 '''
23 输出：
24 I am done
25 0.00021631981540709086
26 '''
（2），被装饰的函数有返回值：
1 def decorator(func):
2 def wrapper(arg):
3 t1 = time.perf_counter()
4 i = func(arg)
5 print(time.perf_counter()-t1)
6 return i
7 return wrapper
8
9 @decorator
10 def func(arg): #有返回值
11 i = 1
12 while(1):
13 i+=1
14 if i>1000:
15 print(arg)
16 break
17
18 return i
19
20
21 if __name__ =="__main__":
22 import time
23 i = func("I am done")
24 print(i)
25 '''
26 输出：
27 I am done
28 9.514658547491372e-05
29 1001
30 '''
内部原理：它利用的就是语法糖@：
@decorator 在一个函数的上方实际是：
func = decorator(func)
证明如下：
1 def decorator(func):
2 print("I am decorator")
3
4 @decorator #----> func = decorator(func)
5 def func(arg):
6 print("I am func")
7
8
9 if __name__ =="__main__":
10 pass
11
12 '''
13 输出：
14 I am decorator
15 '''
类的装饰器：
它其实和函数装饰器是一样的，
1 def decorator(obj): #装饰器本质上是给对象装饰，obj，所以类对象（类名）也可以
2 print("-------->",obj)
3 obj.x = 1 #添加的类属性
4 obj.y = 2
5 return obj
6
7 @decorator
8 class DemoClass:
9 pass
10
11
12 if __name__ =="__main__":
13 demo = DemoClass()
14 print(DemoClass.__dict__)
15 print(demo.__dict__)
16 '''
17 输出：
18 --------> <class '__main__.DemoClass'>
19 {'__dict__': <attribute '__dict__' of 'DemoClass' objects>, '__module__': '__main__', 'x': 1, '__doc__': None, 'y': 2, '__weakref__': <attribute '__weakref__' of 'DemoClass' objects>}
20 {}
21 '''
补：函数名也是个对象，如下：
1 def test():
2 pass
3 test.x = 1 #理论上是可以这么干的，这说明了一切皆对象
4 test.y = 2
5
6 if __name__ =="__main__":
7 print(test.__dict__)
8
9 '''
10 输出：{'x': 1, 'y': 2}
11 '''
而语法糖@的工作就是将它后面的对象作为参数传入，处理完之后再返回该对象。
继续类的装饰器：
1 def decorator(obj): 2 obj.x = 1 3 return obj 4 5 @decorator 6 class Democlass: 7 pass 8 9 10 if __name__ =="__main__": 11 pass 12 13 如果是这样的话，以后再想添加新的类属性就不方便了！
改进：
1 def decorator(**kwargs):
2 def deco(obj): #真正的装饰，装饰Democlass
3 for k,v in kwargs.items():
4 # obj.__dict__[k]=v #会报错 TypeError: 'mappingproxy' object does not support item assignment
5 setattr(obj,k,v) #这种方式可以
6 return obj
7 return deco
8
9 @decorator(x=1,y=2,z=3) #1，先执行decorator(x=1,y=2,z=3) 2,返回结果再执行装饰Democlass
10 class Democlass:
11 pass
12
13
14 if __name__ =="__main__":
15 print(Democlass.__dict__)
16
17 '''
18 输出：
19 {'__doc__': None, 'y': 2, 'x': 1, 'z': 3, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Democlass' objects>, '__weakref__': <attribute '__weakref__' of 'Democlass' objects>}
20 '''
这就是类的装饰器。
（装饰器就是个函数）
类的装饰器的应用：
配合描述符一起使用：（描述符的应用在这：https://www.cnblogs.com/zach0812/p/11312252.html）
class Person:
name = Check("name",str)
age = Check("age",int)
salary = Check("salary",float) #它们三个都是给类增加属性，所以可以考虑通过类装饰器增加属性
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary
1 def decorator(**kwargs):
2 def deco(obj):
3 for k,v in kwargs.items():
4 setattr(obj,k,v)
5 return obj
6 return deco
7
8 class Check:
9 def __init__(self,key,type):
10 self.key = key
11 self.type= type
12
13 def __set__(self, instance, value):
14 print("set")
15 if isinstance(value,self.type):
16 instance.__dict__[self.key] = value
17 else:
18 print("{}输入有误".format(self.key))
19 # raise TypeError("{}输入有误".format(self.key))
20 def __get__(self, instance, owner):
21 print("get")
22 return instance.__dict__[self.key]
23
24 def __delete__(self, instance):
25 print("delete")
26 instance.__dict__.pop(self.key)
27
28 @decorator(name = Check("name",str),age = Check("age",int),salary = Check("salary",float))
29 class Person:
30 def __init__(self,name,age,salary):
31 self.name = name
32 self.age = age
33 self.salary = salary
34
35 if __name__ =="__main__":
36 p1 = Person("tom",18,100.0)
37 print("============")
38 p2 = Person(108,"tom","jack")
39 '''
40 输出：
41 set
42 set
43 set
44 ============
45 set
46 name输入有误
47 set
48 age输入有误
49 set
50 salary输入有误
51 '''
终结版：
1 def decorator(**kwargs):
2 def deco(obj):
3 for k,v in kwargs.items():
4 setattr(obj,k,Check(k,v))
5 return obj
6 return deco
7
8 class Check:
9 def __init__(self,key,type):
10 self.key = key
11 self.type= type
12
13 def __set__(self, instance, value):
14 print("set")
15 if isinstance(value,self.type):
16 instance.__dict__[self.key] = value
17 else:
18 print("{}输入有误".format(self.key))
19 # raise TypeError("{}输入有误".format(self.key))
20 def __get__(self, instance, owner):
21 print("get")
22 return instance.__dict__[self.key]
23
24 def __delete__(self, instance):
25 print("delete")
26 instance.__dict__.pop(self.key)
27
28 @decorator(name = str,age = int,salary = float) #相对上一个，进一步简化代码
29 class Person:
30 def __init__(self,name,age,salary):
31 self.name = name
32 self.age = age
33 self.salary = salary
34
35 if __name__ =="__main__":
36 p1 = Person("tom",18,100.0)
37 print("============")
38 p2 = Person(108,"tom","jack")
39 '''
40 输出：
41 set
42 set
43 set
44 ============
45 set
46 name输入有误
47 set
48 age输入有误
49 set
50 salary输入有误
51 '''
这就是终结版的对类型检测的程序，
不过，我们也可以用@property 来进行检测。但是它不好，我们不用，但是这里要说下它！
1 class DemoClass: 2 def __init__(self): 3 pass 4 5 @property 6 def age(self): 7 return self._age 8 9 @age.setter 10 def age(self,val): 11 if val <0: 12 self._age = 30 13 else: 14 self._age = val 15 16 if __name__=="__main__": 17 demo = DemoClass() 18 demo.age = -50 19 print(demo.age)
property的使用（2）：
1 class DemoClass:
2 def __init__(self,name):
3 self.name = name
4
5 @property
6 def age(self):
7 pass
8
9 @age.setter
10 def age(self,val):
11 # self.age = val #会构成递归
12 self.__dict__['age'] =val
13 @age.getter
14 def age(self):
15 # return self.age #递归
16 return self.__dict__['age']
17
18 @age.deleter
19 def age(self):
20 # del self.age #递归
21 del self.__dict__['age']
22
23 if __name__ == "__main__":
24 demo = DemoClass("tom")
25 demo.age = 18
26 print(demo.age)
27 del demo.age
28 '''
29 输出：
30 18
31 {'age': 18, 'name': 'tom'}
32 '''
class DemoClass:
def __init__(self,name):
self.name = name
@property # age = property(age) age 此时为property类 的对象
def age(self):
print("2")
return self.__dict__['age']
@age.setter
def age(self,val):
self.__dict__['age'] =val
@age.getter
def age(self):
print("1")
return self.__dict__['age']
@age.deleter
def age(self):
del self.__dict__['age']
if __name__ == "__main__":
demo = DemoClass("tom")
demo.age = 20
demo.age
'''
输出:1 ,有age.getter()时就不调property()了，没有的话会调它
'''
它之所以不好用，就是因为它不能复用，每要检测一个属性的取值范围都要新写一个。不像上面描述符写的灵活！
现在我们利用描述符自己手写个自制的property装饰器.
之前说的函数的装饰器和类的装饰器都是函数，其实类也可以作为装饰器。
1 class Myproperty:
2 def __init__(self,func):
3 self.func = func
4
5 class DemoClass:
6 def __init__(self,name):
7 self.name = name
8 @Myproperty # age = Myproperty(age) age 此时为Myproperty类 的对象
9 def age(self): #age 在类的属性字典中,是个类属性
10 print("hello")
11
12 if __name__ == "__main__":
13 demo = DemoClass("tom")
14 print(demo.__dict__)
15 print(DemoClass.__dict__)
16
17 '''
18 输出：
19 {'name': 'tom'}
20 {'__dict__': <attribute '__dict__' of 'DemoClass' objects>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'DemoClass' objects>, '__init__': <function DemoClass.__init__ at 0x000001A7732C3BF8>, '__module__': '__main__', 'age': <__main__.Myproperty object at 0x000001A7732BFBE0>}
21 '''
现在的age是个类属性了，我们可以通过描述符对它进行属性管理（让它成为property那种的不加括号就调用了def age()）。
1 class Myproperty:
2 def __init__(self,func):
3 self.func = func
4
5 def __get__(self, instance, owner): #使Myproperty 成为非数据描述符
6 return self.func(instance) #instance 是省略的self
7
8 class DemoClass:
9 def __init__(self,name,width,length):
10 self.name = name
11 self.width = width
12 self.length = length
13 @Myproperty # area = Myproperty(area)
14 def area(self):
15 return self.width*self.length
16
17
18 if __name__ == "__main__":
19 demo = DemoClass("厕所",15,10)
20 print(demo.area) #实际上调的还是def area ()
@语法糖都是利用描述符的原理来做的，还可以自定制@classmethod 和 classstaticmethod
来源：https://www.cnblogs.com/zach0812/p/11312971.html