第073讲：类和对象（XVI）

hveagle

1. >>> X = 10
   
2. >>> V = 5
   
3. >>> I = 1
   
4. >>> XVI = X + V + I
   
5. >>> print(XVI)
   
6. 16

复制代码

小古比鱼

本节讲了两个基本概念：类方法和静态方法。类方法是指用于绑定类的方法，用@classmethod装饰器来定义，绑定的是类而非实例对象；静态方法则是指放在类中的函数，用@staticmethod装饰器来定义，无需绑定。使用类方法和静态方法都不必担心实例属性覆盖类属性的问题。实际中要根据应用场景“因地制宜”，当操作不涉及类属性或实例属性引用时使用静态方法，当统计实例对象数量时使用类方法更好，在涉及继承时可实现自动化，分别统计，易于扩展，简单便捷！

Ensoleile

类方法和静态方法

1. #类方法：classmethod装饰器，绑定的是一个类而非对象
   
2. class C:
   
3.     def funA(self):
   
4.         print(self)
   
5.     @classmethod
   
6.     def funB(cls):
   
7.         print(cls)
   
8. 
   
9. c = C()
   
10. c.funA()#<__main__.C object at 0x000001AAF996CFA0>
    
11. c.funB()#<class '__main__.C'>
    
12. #普通方法绑定的是一个对象object，类方法绑定的是类C
    
13. #self和cls均为约定俗成的写法，更换了也没有错
    
14. 
    
15. class C:
    
16.     count = 0
    
17.     def __init__(self):
    
18.         C.count += 1
    
19.     @classmethod
    
20.     def get_count(cls):
    
21.         print(f'该类一共实例化了{cls.count}个对象')
    
22. 
    
23. c1 = C()
    
24. c2 = C()
    
25. c3 = C()
    
26. c1.get_count()#该类一共实例化了3个对象
    
27. #如果在一个对象中创建一个跟类属性同名的实例属性，则后者就会覆盖类属性，但这里由于get_count是类方法，所以就算实例属性覆盖了类属性，也不会改变类属性
    
28. c3.count = 1
    
29. print(c3.count)#1
    
30. c3.get_count()#该类一共实例化了3个对象
    
31. print(C.count)#3
    
32. # 虽然直接使用类名来访问类属性也可以，但如果涉及到继承问题，那么使用类方法会有更大的优势
    
33. 
    
34. # 静态方法：staticmethod装饰器，放在类里边的函数。在类里边定义一个不需要绑定对象（self）的函数
    
35. class C:
    
36.     @staticmethod
    
37.     def funC():
    
38.         print('i love you')
    
39. 
    
40. c = C()
    
41. c.funC()# i love you
    
42. C.funC()# i love you
    
43. 
    
44. class C:
    
45.     count = 0
    
46.     def __init__(self):
    
47.         C.count += 1
    
48.     @staticmethod
    
49.     def get_count():
    
50.         print(f'该类一共实例化了{C.count}个对象')
    
51. 
    
52. c1 = C()
    
53. c2 = C()
    
54. c3 = C()
    
55. c1.get_count()#该类一共实例化了3个对象
    
56. c3.count = 1
    
57. print(C.count)#3
    
58. 
    
59. # 当操作不涉及类属性或实例属性引用时使用静态方法比较合适，如果像统计实例对象这种任务时，使用类方法实现更好
    
60. class C:
    
61.     count = 0
    
62.     @classmethod
    
63.     def add(cls):
    
64.         cls.count += 1
    
65.     def __init__(self):
    
66.         self.add()
    
67.     @classmethod
    
68.     def get_count(cls):
    
69.         print(f'该类一共实例化了{cls.count}个对象')
    
70. 
    
71. class D(C):
    
72.     count = 0
    
73. 
    
74. class E(C):
    
75.     count = 0
    
76. 
    
77. c1 = C()
    
78. d1, d2 = D(), D()
    
79. e1, e2, e3 = E(), E(), E()
    
80. c1.get_count()#该类一共实例化了1个对象
    
81. d1.get_count()#该类一共实例化了2个对象
    
82. e1.get_count()#该类一共实例化了3个对象
    
83. # 当代码涉及到继承的时候，实例对象的数量统计就变得复杂了，此时类方法的优势便体现出来了。独立出一个add()的类方法，这样做是为了实现自动化，让构造函数调用add()类方法，就不用管他是子类还是父类，谁去调用谁就会自动把对应的类传递进去，那么递增的也就是该类对应的count类属性，相当于各回各家各找各妈。我们要做的就是在继承的时候覆盖一下对应类的count属性，就可以轻松实现各个类实例的对象数量统计。
    

复制代码

我又可以了

1. count=0
   
2. >>> class C:
   
3.         def __init__(self):
   
4.                 global count
   
5.                 count+=1
   
6.         def count1(self):
   
7.                 print(f"该类一共实例化了{count}个对象。")
   
8. 
   
9.                
   
10. >>> c=C()
    
11. >>> f=C()
    
12. >>> g=C()
    
13. >>> v=C()
    
14. >>> k=C()
    
15. >>> k.count1 ()
    
16. 该类一共实例化了5个对象。
    
17. >>> g.count1 ()
    
18. 该类一共实例化了5个对象。

复制代码

以上代码不用类方法绑定类，也能实现统计类实例化对象的个数
但是，如果绑定对象，则统计过程停止在指定的实例化对象，代码如下：

1. count=0
   
2. >>> class C:
   
3.         def __init__(self):
   
4.                 global count
   
5.                 count+=1
   
6.                 self.value=count
   
7.         def count1(self):
   
8.                 print(f"该类一共实例化了{self.value}个对象。")
   
9. 
   
10.                
    
11. >>> c=C()
    
12. >>> b=C()
    
13. >>> v=C()
    
14. >>> f=C()
    
15. >>> g=C()
    
16. >>> g.count1()
    
17. 该类一共实例化了5个对象。
    
18. >>> f.count1()
    
19. 该类一共实例化了4个对象。

复制代码

新手望指教！