一个非常重要的实际差异发生在子类化时。如果你不介意的话，我会劫持@unsubu的例子：

class A: 
    def foo(self, x): 
        print("executing foo(%s, %s)" % (self, x)) 
 
    @classmethod
    def class_foo(cls, x): 
        print("executing class_foo(%s, %s)" % (cls, x))
 
    @staticmethod 
    def static_foo(x): 
        print("executing static_foo(%s)" % x)

class B(A):
    pass

在class_foo中，该方法知道它是在哪个类上调用的：

A.class_foo(1)
# => executing class_foo(<class '__main__.A'>, 1)
B.class_foo(1)
# => executing class_foo(<class '__main__.B'>, 1)

在static_foo中，无法确定它是在A还是B上调用的：

A.static_foo(1)
# => executing static_foo(1)
B.static_foo(1)
# => executing static_foo(1)

注意，这并不意味着您不能在静态方法中使用其他方法，您只需直接引用类，这意味着子类的静态方法仍将引用父类：

class A:
    @classmethod
    def class_qux(cls, x):
        print(f"executing class_qux({cls}, {x})")
    
    @classmethod
    def class_bar(cls, x):
        cls.class_qux(x)

    @staticmethod
    def static_bar(x):
        A.class_qux(x)

class B(A):
    pass

A.class_bar(1)
# => executing class_qux(<class '__main__.A'>, 1)
B.class_bar(1)
# => executing class_qux(<class '__main__.B'>, 1)
A.static_bar(1)
# => executing class_qux(<class '__main__.A'>, 1)
B.static_bar(1)
# => executing class_qux(<class '__main__.A'>, 1)

太长，读不下去了

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

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

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

Python中@staticmethod和@classmethod之间有什么区别？

您可能已经看到了类似于此伪代码的Python代码，它演示了各种方法类型的签名，并提供了一个文档字符串来解释每种类型：

class Foo(object):

    def a_normal_instance_method(self, arg_1, kwarg_2=None):
        '''
        Return a value that is a function of the instance with its
        attributes, and other arguments such as arg_1 and kwarg2
        '''

    @staticmethod
    def a_static_method(arg_0):
        '''
        Return a value that is a function of arg_0. It does not know the 
        instance or class it is called from.
        '''

    @classmethod
    def a_class_method(cls, arg1):
        '''
        Return a value that is a function of the class and other arguments.
        respects subclassing, it is called with the class it is called from.
        '''

普通实例方法

首先，我将解释a_nonormal_instance_method。这就是所谓的“实例方法”。当使用实例方法时，它被用作部分函数（与在源代码中查看时为所有值定义的总函数相反），也就是说，当使用时，第一个参数被预定义为对象的实例及其所有给定属性。它绑定了对象的实例，并且必须从对象的实例调用它。通常，它将访问实例的各种属性。

例如，这是一个字符串的实例：

', '

如果我们使用实例方法join来连接另一个可迭代的字符串，很明显，它是实例的函数，除了是可迭代列表['a'，'b'，'c']的函数之外：

>>> ', '.join(['a', 'b', 'c'])
'a, b, c'

绑定的方法

实例方法可以通过点查找绑定，以便稍后使用。

例如，这将str.join方法绑定到“：”实例：

>>> join_with_colons = ':'.join 

稍后，我们可以将其用作已经绑定了第一个参数的函数。这样，它就像实例上的分部函数一样工作：

>>> join_with_colons('abcde')
'a:b:c:d:e'
>>> join_with_colons(['FF', 'FF', 'FF', 'FF', 'FF', 'FF'])
'FF:FF:FF:FF:FF:FF'

静态方法

静态方法不将实例作为参数。

它非常类似于模块级函数。

但是，模块级函数必须存在于模块中，并且必须专门导入到使用它的其他地方。

然而，如果它附加到对象，它将通过导入和继承方便地跟随对象。

静态方法的一个示例是str.maketrans，它是从Python 3中的字符串模块移动来的。它使转换表适合str.translate使用。从字符串的实例中使用它似乎很愚蠢，如下所示，但从字符串模块导入函数相当笨拙，能够从类中调用它很好，如str.maketrans中所示

# demonstrate same function whether called from instance or not:
>>> ', '.maketrans('ABC', 'abc')
{65: 97, 66: 98, 67: 99}
>>> str.maketrans('ABC', 'abc')
{65: 97, 66: 98, 67: 99}

在python 2中，您必须从越来越无用的字符串模块导入此函数：

>>> import string
>>> 'ABCDEFG'.translate(string.maketrans('ABC', 'abc'))
'abcDEFG'

Class方法

类方法与实例方法相似，因为它接受隐式的第一个参数，但不是接受实例，而是接受类。为了更好地使用语义，它们通常被用作替代构造函数，它将支持继承。

内置类方法最典型的例子是dict.fromkeys。它被用作dict的另一个构造函数（非常适合当你知道你的键是什么并且想要它们的默认值时）

>>> dict.fromkeys(['a', 'b', 'c'])
{'c': None, 'b': None, 'a': None}

当我们对dict进行子类化时，我们可以使用相同的构造函数来创建子类的实例。

>>> class MyDict(dict): 'A dict subclass, use to demo classmethods'
>>> md = MyDict.fromkeys(['a', 'b', 'c'])
>>> md
{'a': None, 'c': None, 'b': None}
>>> type(md)
<class '__main__.MyDict'>

请参阅panda源代码以了解其他类似的替代构造函数示例，也可以参阅关于classmethod和staticmethod的Python官方文档。

静态方法：

没有自参数的简单函数。处理类属性；而不是实例属性。可以通过类和实例调用。内置函数staticmethod（）用于创建它们。

静态方法的优点：

它在类作用域中本地化函数名它将功能代码移动到使用位置附近与模块级函数相比，导入更方便，因为不必专门导入每个方法@静态方法定义some_static_method（*args，**kwds）：通过

类方法：

将第一个参数作为类名的函数。可以通过类和实例调用。这些是用内置函数中的classmethod创建的。@分类法定义some_class_method（cls，*args，**kwds）：通过

我的贡献展示了@classmethod、@staticmethod和实例方法之间的区别，包括实例如何间接调用@staticmmethod。但是，与其从实例间接调用@staticmethod，不如将其私有化可能更“Python化”。这里没有演示从私有方法获取内容，但基本上是相同的概念。

#!python3

from os import system
system('cls')
# %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %

class DemoClass(object):
    # instance methods need a class instance and
    # can access the instance through 'self'
    def instance_method_1(self):
        return 'called from inside the instance_method_1()'

    def instance_method_2(self):
        # an instance outside the class indirectly calls the static_method
        return self.static_method() + ' via instance_method_2()'

    # class methods don't need a class instance, they can't access the
    # instance (self) but they have access to the class itself via 'cls'
    @classmethod
    def class_method(cls):
        return 'called from inside the class_method()'

    # static methods don't have access to 'cls' or 'self', they work like
    # regular functions but belong to the class' namespace
    @staticmethod
    def static_method():
        return 'called from inside the static_method()'
# %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %

# works even if the class hasn't been instantiated
print(DemoClass.class_method() + '\n')
''' called from inside the class_method() '''

# works even if the class hasn't been instantiated
print(DemoClass.static_method() + '\n')
''' called from inside the static_method() '''
# %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %   %

# >>>>> all methods types can be called on a class instance <<<<<
# instantiate the class
democlassObj = DemoClass()

# call instance_method_1()
print(democlassObj.instance_method_1() + '\n')
''' called from inside the instance_method_1() '''

# # indirectly call static_method through instance_method_2(), there's really no use
# for this since a @staticmethod can be called whether the class has been
# instantiated or not
print(democlassObj.instance_method_2() + '\n')
''' called from inside the static_method() via instance_method_2() '''

# call class_method()
print(democlassObj.class_method() + '\n')
'''  called from inside the class_method() '''

# call static_method()
print(democlassObj.static_method())
''' called from inside the static_method() '''

"""
# whether the class is instantiated or not, this doesn't work
print(DemoClass.instance_method_1() + '\n')
'''
TypeError: TypeError: unbound method instancemethod() must be called with
DemoClass instance as first argument (got nothing instead)
'''
"""

关于staticmethod vs classmethod的另一个考虑是继承。假设你有以下课程：

class Foo(object):
    @staticmethod
    def bar():
        return "In Foo"

然后您需要在子类中重写bar（）：

class Foo2(Foo):
    @staticmethod
    def bar():
        return "In Foo2"

这是可行的，但请注意，现在子类（Foo2）中的bar（）实现不能再利用该类特有的任何特性。例如，假设Foo2有一个名为magic（）的方法，您希望在Foo2实现bar（）时使用该方法：

class Foo2(Foo):
    @staticmethod
    def bar():
        return "In Foo2"
    @staticmethod
    def magic():
        return "Something useful you'd like to use in bar, but now can't" 

这里的解决方法是在bar（）中调用Foo2.magic（），但随后您重复自己的操作（如果Foo2的名称发生更改，您必须记住更新bar（）方法）。

对我来说，这稍微违反了开放/封闭原则，因为在Foo中做出的决定会影响您重构派生类中的公共代码的能力（即扩展的开放性较低）。如果bar（）是一个类方法，我们就可以了：

class Foo(object):
    @classmethod
    def bar(cls):
        return "In Foo"

class Foo2(Foo):
    @classmethod
    def bar(cls):
        return "In Foo2 " + cls.magic()
    @classmethod
    def magic(cls):
        return "MAGIC"

print Foo2().bar()

给出：In Foo2 MAGIC

此外：历史笔记：Guido Van Rossum（Python的创建者）曾将静态方法称为“意外”：https://mail.python.org/pipermail/python-ideas/2012-May/014969.html

我们都知道静态方法有多有限。（它们基本上是一个意外——回到Python 2.2时代，当我发明新型类和描述符时，我想实现类方法，但一开始我不理解它们，意外地先实现了静态方法。然后，删除它们，只提供类方法已经太晚了。

也：https://mail.python.org/pipermail/python-ideas/2016-July/041189.html

老实说，staticmethod是一个错误——我试图做一些类似Java类方法的事情，但一旦发布，我发现真正需要的是类方法。但要摆脱静态方法为时已晚。