太长，读不下去了

静态方法本质上是绑定到类（及其实例）的函数

类方法本质上是一种可继承的静态方法。

有关详细信息，请参阅其他人的优秀答案。

我将用一个例子来解释基本的区别。

class A(object):
    x = 0

    def say_hi(self):
        pass

    @staticmethod
    def say_hi_static():
        pass

    @classmethod
    def say_hi_class(cls):
        pass

    def run_self(self):
        self.x += 1
        print self.x # outputs 1
        self.say_hi()
        self.say_hi_static()
        self.say_hi_class()

    @staticmethod
    def run_static():
        print A.x  # outputs 0
        # A.say_hi() #  wrong
        A.say_hi_static()
        A.say_hi_class()

    @classmethod
    def run_class(cls):
        print cls.x # outputs 0
        # cls.say_hi() #  wrong
        cls.say_hi_static()
        cls.say_hi_class()

1-我们可以直接调用静态和类方法，而无需初始化

# A.run_self() #  wrong
A.run_static()
A.run_class()

2-静态方法不能调用self方法，但可以调用其他静态和类方法

3-静态方法属于类，根本不会使用对象。

4-类方法不绑定到对象，而是绑定到类。

要决定是使用@staticmethod还是@classmethod，必须查看方法内部。如果您的方法访问类中的其他变量/方法，请使用@classmethod。另一方面，如果您的方法不涉及类的任何其他部分，则使用@staticmethod。

class Apple:

    _counter = 0

    @staticmethod
    def about_apple():
        print('Apple is good for you.')

        # note you can still access other member of the class
        # but you have to use the class instance 
        # which is not very nice, because you have repeat yourself
        # 
        # For example:
        # @staticmethod
        #    print('Number of apples have been juiced: %s' % Apple._counter)
        #
        # @classmethod
        #    print('Number of apples have been juiced: %s' % cls._counter)
        #
        #    @classmethod is especially useful when you move your function to another class,
        #       you don't have to rename the referenced class 

    @classmethod
    def make_apple_juice(cls, number_of_apples):
        print('Making juice:')
        for i in range(number_of_apples):
            cls._juice_this(i)

    @classmethod
    def _juice_this(cls, apple):
        print('Juicing apple %d...' % apple)
        cls._counter += 1

顾名思义，类方法用于更改类而不是对象。要对类进行更改，它们将修改类属性（而不是对象属性），因为这就是更新类的方式。这就是类方法将类（通常用“cls”表示）作为第一个参数的原因。

class A(object):
    m=54

    @classmethod
    def class_method(cls):
        print "m is %d" % cls.m

另一方面，静态方法用于执行未绑定到类的功能，即它们不会读取或写入类变量。因此，静态方法不将类作为参数。使用它们是为了使类可以执行与类的目的不直接相关的功能。

class X(object):
    m=54 #will not be referenced

    @staticmethod
    def static_method():
        print "Referencing/calling a variable or function outside this class. E.g. Some global variable/function."

当存在继承时，就会出现差异。

假设有两个类——父类和子类。如果要使用@staticmethod，print_name方法应该写两次，因为类的名称应该写在打印行中。

class Parent:
   _class_name = "Parent"

   @staticmethod
   def print_name():
       print(Parent._class_name)


class Child(Parent):
   _class_name = "Child"

   @staticmethod
   def print_name():
       print(Child._class_name)


Parent.print_name()
Child.print_name()

但是，对于@classmethod，不需要编写print_name方法两次。

class Parent:
    _class_name = "Parent"

    @classmethod
    def print_name(cls):
        print(cls._class_name)


class Child(Parent):
    _class_name = "Child"


Parent.print_name()
Child.print_name()

分析@staticmethod，提供不同的见解。

类的普通方法是一种隐式动态方法，它将实例作为第一个参数。相反，静态方法不将实例作为第一个参数，因此称为“static”。

静态方法确实是一个与类定义之外的函数相同的正常函数。幸运的是，它被分组到类中，只是为了更接近应用它的位置，或者您可以滚动查找它。