Classmethod and Staticmethod - Python 类方法 和 静态方法

 classmethod and staticmethod
     classmethod 的是一个参数是类对象 cls (本类,或者子类), 而不是实例对象 instance (普通方法). classmethod 即可以通过'类'调用 - cls.classfunc(),
     也可以同通过实例调用('The instance is ignored except for its class')- instance.classfunc() / cls().classfunc()
     当通过'子类'调用'基类'的 classmethod 的时候, '子类'的类对象被当做第一个参数处理.
         'When a class attribute reference (for class C, say) would yield a class method object,
          it is transformed into an instance method object whose __self__ attributes is C. '

     举个例子,
         class A(object):

             @classmethod
             def func(cls):
                 print(cls)
                 print('A - classmethod')

         class B(A):
             pass

         if __name__ == "__main__":
             A.func()                    #1       通过本类的'类对象'调用 classmethod
             abc = A()
             abc.func()                  #2       通过本类的'实例对象'调用 classmethod
             B.func()                    #3       通过子类的'类对象' 调用 classmethod
             bcd = B()
             bcd.func()                  #4       通过子类的'实例对象'调用 classmethod

         Output,
             <class '__main__.A'>        #5       classmethod 的第一个参数是 '类对象'
             A - classmethod
             <class '__main__.A'>
             A - classmethod
             <class '__main__.B'>        #6       通过'子类'调用'基类'的 classmethod 的时候, '子类' 的类对象被当做第一个参数处理
             A - classmethod
             <class '__main__.B'>
             A - classmethod

     staticmethod 的第一个参数不在是'特殊参数'(cls 类本身, 或 self 实例), 可以将 staticmethod 理解为定义在类定义提中的普通函数.
     staticmethod 提供了一个将 function objects 转换成 method objects 的方式. staticmethod 本身是不可调用的(not callable),
     然而通过
     staticmethod 即可以通过'类'调用 - cls.staticfunc(),
     也可以同通过实例调用('The instance is ignored except for its class')- instance.staticfunc() / cls().staticfunc()

         'When it would yield a static method object, it is transformed into the object wrapped by the static method object'

     例子,
         class A(object):

             @staticmethod
             def func():
                 #print(callable(A.func))
                 print('A - staticmethod')

         class B(A):
             pass

         if __name__ == "__main__":
             A.func()                    #1       通过本类的'类对象'调用 staticmethod
             abc = A()
             abc.func()                  #2       通过本类的'实例对象'调用 staticmethod
             B.func()                    #3       通过子类的'类对象' 调用 staticmethod
             bcd = B()
             bcd.func()                  #4       通过子类的'实例对象'调用 staticmethod

         Output,
             A - staticmethod
             A - staticmethod
             A - staticmethod
             A - staticmethod

     Static method objects
         Static method objects provide a way of defeating the transformation of function objects to method objects.
         A static method object is a wrapper around any other object, usually a user-defined method object.
         When a static method object is retrieved from a class or a class instance, the object actually returned is the wrapped object,
         which is not subject to any further transformation. Static method objects are not themselves callable,
         although the objects they wrap usually are.
         Static method objects are created by the built-in staticmethod() constructor.
         It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class.
         If a class method is called for a derived class, the derived class object is passed as the implied first argument.

     Class method objects
         A class method object, like a static method object, is a wrapper around another object that alters the way
         in which that object is retrieved from classes and class instances.
         Class method objects are created by the built-in classmethod() constructor.
         It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class.

     *** 注, decorator 返回的是可调用的函数或方法对象.
             通常 classmethod 和 staticmethod 是通过装饰器 @classmethod 和 @staticmethod 实现的.