Python静态方法@staticmethod和类方法@classmethod

Python静态方法@staticmethod和类方法@classmethod经常出现在类的定义中，二者和常规实例方法之间有什么区别呢？先看例子：

class A:   
      cnt = 0   
      val = 1   
      def __init__(self, cnt=0, val=1):   
          self.val = val   
          A.cnt += 1   
         
      def normal_fun(self, x):   
          print(x + self.val)   
         
      @classmethod   
      def get_cnt(cls, x):   
          print('cnt:', A.cnt)   
          print(str(x) + '+val:', x+A.val)   
          cls().normal_fun(x)
  
      @staticmethod   
      def _add(x, y):   
          print(x + y)   

其中，第一个方法normal_fun(self, x)是常规实例方法，前面有@classmethod修饰符声明的方法get_cnt(cls, x)是类方法，前面有@staticmethod修饰符声明的方法_add(x, y)是静态方法。

三者的不同：

（1）从定义上来说

常规实例方法定义时前面不需要任何修饰符声明，其括号内的第一个参数必须是self；
类方法定义时前面必须用中@classmethod修饰符声明，括号中的第一个参数必须是cls；
静态方法定义时前面必须用中@staticmethod修饰符声明，括号中的参数和普通函数一样，不需要添加self或cls。

（2）从用法上来说

常规实例方法绑定类的实例，必须用类的实例引用，直接用类名引用将报错，如：

In [2]: a = A()      # 最常引用方法，用实例引用                                                           

In [3]: a.normal_fun(1)                                                         
2

In [4]: A.normal_fun(1)           # 用类名引用将报错                                              
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 A.normal_fun(1)

TypeError: normal_fun() missing 1 required positional argument: 'x'

In [5]: A.normal_fun(a,1)              # 也可以这样引用，不常用                                         
2

类方法和静态方法绑定类，既可以用类名引用，也可以用实例引用，如下：

In [3]: A.get_cnt(1)               # 类名引用                                             
cnt: 1
1+val: 2
2

In [4]: a.get_cnt(1)                 # 实例引用                                           
cnt: 2
1+val: 2
2

In [11]: A._add(1,1)                                                            
2

In [12]: a._add(1,1)                                                            
2

（3）从应用场景上讲

常规实例方法最为常见，其定义的方法一般都要使用init方法中的类属性，从而完成某项类要实现的功能。

类方法在执行时，调用它的类将自动约束到方法的cls参数，可通过这个参数访问类的其它参数。这句话怎么理解呢？例子中的类方法get_cnt的最后一句cls().normal_fun(x)，即此时cls()将代表类A来访问A中的normal_fun方法，相当于A.normal_fun(x)。

     @classmethod  
     def get_cnt(cls, x):  
         print('cnt:', A.cnt)  
         print(str(x) + '+cnt:', x+A.cnt)  
         cls().normal_fun(x)  # 引用其它方法，相当于A.normal_fun(x)

In [2]: A.get_cnt(1)                                                            
cnt: 1
1+val: 2
2      # 引用normal_fun(1)的输出

人们通常用类方法实现与本类的所有对象有关的操作，如本例中，类方法get_cnt的作用是记录程序运行中创建的类A的实例对象的个数，每创建一个A类实例，cnt的值便会加1，用第一个print语句输出计数值。第二个print语句是为了说明类方法如何引用init中的属性。

# 此示例为删除cls().normal_fun(x)语句后的运行结果
In [7]: a = A()           # 第一次创建类实例                                                      

In [8]: A.get_cnt(1)                                                            
cnt: 1
1+val: 2

In [9]: b = A()           # 第二次创建类实例                                                      

In [10]: A.get_cnt(1)                                                           
cnt: 2
1+val: 2

In [11]: c = A()          # 第三次创建类实例                                                      

In [12]: A.get_cnt(1)                                                           
cnt: 3
1+val: 2

静态方法的实质是与类无关的普通函数，原本可将其定义在类外面作为全局函数使用，但出于某种原因，比如为了更好的组织代码，使编程模块更清晰，命名空间更整洁，将其置于类内作为局部函数使用。比如Python中有add()函数，numpy中也有add()函数，使用类名.方法名的引用方法将很好的避免np.add()和Python中的add()冲突。

其中，类方法的使用场景比较模糊，所以静态方法比类方法更为常见，且二者的定义中几乎都不会使用init中的类属性，我看了很多使用类方法的示例，用静态方法完全可以代替之，所以不用纠结到底用哪个，一般要用到init中的类属性时就用常规方法，不需要init中的类属性时就用静待方法。

（4）使用init中的类属性和其它类方法时：

常规实例方法:

self.属性名
self.方法名

比如本文例子中的normal_fun方法，使用类属性val时直接用self.val的形式。
类方法和静态方法：

类名.属性名
类名.方法名

如本例中get_cnt方法在使用val时采用A.val来引用，而不是self.val。