第077讲：类和对象（XX）

小甲鱼

0. 本节视频




1. 温馨提示

如果在学习本节课的过程中遇到问题，可以在这个帖子下方提问哦~

hveagle

老师，视频呢

ty5777

大概什么时候可以完结啊？

小古比鱼

这节课讲解了一个新的概念——类装饰器。类装饰器就是将装饰器作用在类上面，在类被实例化对象之前对其进行拦截和干预，用法与装饰函数的装饰器非常相似。函数可以用来装饰类（类装饰器），反过来，类也可以用作装饰器来装饰函数，使函数成为类的实例化对象，调用函数便会触发类的__call__()等一系列魔法方法。由此，类与函数的“亲密”关系也得以进一步发展！
类装饰器也有容易踩到的“坑”：当类作装饰器用于装饰另一个类时，被装饰类的多次实例化对象实则为装饰类的同一个对象，不过是将其作为函数调用了若干次，因而会导致属性覆盖问题。解决方法是将装饰器类“套一层外壳”，放在一个函数中，由函数返回该类，再将该函数用作装饰器来装饰被装饰类即可。
话说最近几节课的知识点真的是越来越难了！小古比鱼目前只能理清大致思路，自己编写代码恐怕手足无措……也不知类和对象还有多少节，希望小甲鱼老师早日更新类和对象的课后作业！

Ensoleile

# 类装饰器

1. def report(cls):
   
2.     def oncall(*args, **kwargs):
   
3.         print('开始实例化对象')
   
4.         _ = cls(*args, **kwargs)
   
5.         print('实例化对象完成')
   
6.         return _
   
7.     return oncall
   
8. 
   
9. @report
   
10. class C:
    
11.     pass
    
12. 
    
13. c = C()
    
14. # 开始实例化对象
    
15. # 实例化对象完成
    
16. 
    
17. @report
    
18. class C:
    
19.     def __init__(self, x, y, z):
    
20.         self.x = x
    
21.         self.y = y
    
22.         self.z = z
    
23.         print('构造函数被调用')
    
24. 
    
25. c = C(1, 2, 3)
    
26. # 开始实例化对象
    
27. # 构造函数被调用
    
28. # 实例化对象完成
    
29. print(c.__dict__)
    
30. # {'x': 1, 'y': 2, 'z': 3}
    
31. # 类装饰器的作用就是在类被实例化对象之前对其进行拦截和干预
    
32. 
    
33. # 让类做装饰器来装饰函数
    
34. class Counter:
    
35.     def __init__(self):
    
36.         self.count = 0
    
37.     def __call__(self, *args, **kwargs):
    
38.         self.count += 1
    
39.         print(f'已经被调用了{self.count}次')
    
40. 
    
41. c = Counter()
    
42. c()# 已经被调用了1次
    
43. c()# 已经被调用了2次
    
44. c()# 已经被调用了3次
    
45. 
    
46. class Counter:
    
47.     def __init__(self, func):
    
48.         self.count = 0
    
49.         self.func = func
    
50.     def __call__(self, *args, **kwargs):
    
51.         self.count += 1
    
52.         print(f'已经被调用了{self.count}次')
    
53.         return self.func(*args, **kwargs)
    
54. 
    
55. @Counter
    
56. def say_hi():
    
57.     print('hi~')
    
58. 
    
59. print(say_hi)# <__main__.Counter object at 0x000001E41134AFD0>
    
60. # 函数say_hi已经被掉包成Counter的对象
    
61. say_hi()
    
62. # 已经被调用了1次
    
63. # hi~
    
64. say_hi()
    
65. # 已经被调用了2次
    
66. # hi~
    
67. say_hi()
    
68. # 已经被调用了3次
    
69. # hi~
    
70. 
    
71. # 用类做装饰器来装饰类
    
72. class Check:
    
73.     def __init__(self, cls):
    
74.         self.cls = cls
    
75.     def __call__(self, *args, **kwargs):
    
76.         self.obj = self.cls(*args, **kwargs)
    
77.         return self
    
78.     def __getattr__(self, item):
    
79.         print(f'正在访问{item}....')
    
80.         return getattr(self.obj, item)
    
81. 
    
82. @Check
    
83. class C:
    
84.     def say_hi(self):
    
85.         print(f'hi~ -> {self.name}')
    
86.     def say_hey(self):
    
87.         print(f'hey~ -> {self.name}')
    
88. 
    
89. # 将类C改写
    
90. @Check
    
91. class C:
    
92.     def __init__(self, name):
    
93.         self.name = name
    
94.     def say_hi(self):
    
95.         print(f'hi~ -> {self.name}')
    
96.     def say_hey(self):
    
97.         print(f'hey~ -> {self.name}')
    
98. 
    
99. c1 = C('c1')
    
100. c2 = C('c2')
     
101. print(c1.name)
     
102. # 正在访问name....
     
103. # c2
     
104. print(c2.name)
     
105. # 正在访问name....
     
106. # c2
     
107. c1.say_hi()
     
108. # 正在访问say_hi....
     
109. # hi~ -> c2
     
110. c2.say_hey()
     
111. # 正在访问say_hey....
     
112. # hey~ -> c2
     
113. # c1的name属性被c2的name属性覆盖
     
114. print(c1)# <__main__.Check object at 0x000001DB1AB5EF70>
     
115. print(c2)# <__main__.Check object at 0x000002A74A5DEF70>
     
116. # c1和c2其实是Check类的实例对象，其实传递给的是Check类的__call__()魔法方法
     
117. # 对象在@Check时就诞生了，class C在__call__()魔法方法中的第一个语句完成实例化，并将实例化对象传递给了self.obj属性，但返回的是self(Check类的对象自身，而非类C的对象)
     
118. # c1.name、c2.name实际上访问的是Check类对象的name属性，但Check没有name属性，那么他就会试图去查找__getattr__(self, name)这个魔法方法，Check中定义了此方法，返回的是类C的实例化对象
     
119. # Check仅在做装饰器(@Check)时被实例化了一次，那么c1 = C('c1')、c2 = C('c2')只是把对象当函数调用了两次，从而访问了两次相应的__call__()魔法方法，self.obj第一次保存的是name为c1的类C实例化对象，而第二次调用被name为c2的类实例化对象所覆盖
     
120. 
     
121. # 解决bug的方法：
     
122. def report(cls):
     
123.     class Check:
     
124.         def __init__(self, *args, **kwargs):
     
125.             self.obj = cls(*args, **kwargs)
     
126.         def __getattr__(self, item):
     
127.             print(f'正在访问{item}....')
     
128.             return getattr(self.obj, item)
     
129.     return Check
     
130. 
     
131. @report
     
132. class C:
     
133.     def __init__(self, name):
     
134.         self.name = name
     
135.     def say_hi(self):
     
136.         print(f'hi~ -> {self.name}')
     
137.     def say_hey(self):
     
138.         print(f'hey~ -> {self.name}')
     
139. c1 = C('c1')
     
140. c2 = C('c2')
     
141. print(c1.name)
     
142. # 正在访问name....
     
143. # c2
     
144. print(c2.name)
     
145. # 正在访问name....
     
146. # c2
     
147. c1.say_hi()
     
148. # 正在访问say_hi....
     
149. # hi~ -> c1
     
150. c2.say_hey()
     
151. # 正在访问say_hey....
     
152. # hey~ -> c2
     
153. # 由于report返回的是Check类，被@report装饰过的class C其实是被替换为class Check，执行cx = C('cx')时就是在实例化Check类，调用构造函数__init__()，实例化report装饰器装饰过的类class C，然后把实例化的对象保存在self.obj属性中
     
154. # Check被实例化了两次，没有出现属性覆盖的bug

复制代码

Axiujiu

Ensoleile 发表于 2023-1-10 23:36
# 类装饰器

您好，请问第148行，为什么不是打印：正在访问say_hi()....
而是打印：正在访问say_hi....