我认为一个更好的问题是“你什么时候会使用@classmethod vs@staticmethod？”

@classmethod允许您轻松访问与类定义关联的私有成员。这是一种很好的方法来实现单实例，或者控制所创建对象实例数量的工厂类。

@staticmethod提供了边际性能增益，但我还没有看到静态方法在类内的有效使用，而静态方法不能作为类外的独立函数实现。

python官方文档：

@分类法

类方法将类作为隐式第一个参数，就像instance方法接收该实例。要声明类方法，请使用成语：C类：@分类法定义f（cls，arg1，arg2，…）：。。。@classmethod表单是一个函数decorator–请参见函数中的函数定义详细定义。它可以在类上调用（例如C.f（））或实例（例如C（）.f（））。实例是除了它的类之外，都被忽略。如果类方法用于派生类，派生类对象是作为隐含的第一个参数传递。类方法不同于C++或Java静态方法。如果你愿意这些，请参见本文中的staticmethod（）部分

@静态方法

静态方法不接收隐式第一个参数。声明静态方法，使用这个成语：C类：@静态方法定义f（arg1，arg2，…）：。。。@staticmethod表单是一个函数decorator–请参见函数中的函数定义详细定义。它可以在类上调用（例如C.f（））或实例（例如C（）.f（））。实例是除了它的类之外，都被忽略。Python中的静态方法类似类似于Java或C++中的那些。对于更高级的概念，请参见classmethod（）。

我想在前面所有答案的基础上补充以下内容，这不是官方的，但符合标准。

首先，你可以考虑总是给予最少的特权。因此，如果您不需要特定于实例的内容，请将其设置为类方法。如果您不需要特定于类的内容，请将其设置为静态方法。

第二件事是考虑您可以通过创建的方法类型进行通信。静态方法-助手函数意味着在类本身之外使用。类函数-可以在没有实例化的情况下调用，但意味着只能与该类一起使用-否则将是一个静态方法！实例方法-仅用于实例。

这可以帮助您沟通模式以及如何使用代码。

class Foo:
    @classmethod
    def bar(cls, id: int = None):
        query = session.query(
            a.id,
            a.name,
            a.address,
        )

        if id is not None:
            query = query.filter(a.id == id)

        return query

例如，上面提到的——没有理由说明方法栏不能是静态的。然而，通过将其设置为类方法，您可以传达它应该由类本身使用，而不是作为其他地方使用的助手函数！

请记住，以上内容不是官方的，而是我个人的偏好

让我先告诉一下用@classmethod修饰的方法和@staticmethod修饰的方法之间的相似性。

相似性：它们都可以在类本身上调用，而不仅仅是类的实例。所以，在某种意义上，这两种方法都是Class的方法。

区别：类方法将接收类本身作为第一个参数，而静态方法不接收。

因此，在某种意义上，静态方法并不绑定到类本身，只是因为它可能具有相关功能而挂在那里。

>>> class Klaus:
        @classmethod
        def classmthd(*args):
            return args

        @staticmethod
        def staticmthd(*args):
            return args

# 1. Call classmethod without any arg
>>> Klaus.classmthd()  
(__main__.Klaus,)  # the class gets passed as the first argument

# 2. Call classmethod with 1 arg
>>> Klaus.classmthd('chumma')
(__main__.Klaus, 'chumma')

# 3. Call staticmethod without any arg
>>> Klaus.staticmthd()  
()

# 4. Call staticmethod with 1 arg
>>> Klaus.staticmthd('chumma')
('chumma',)

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官方文档。

只有第一个参数不同：

normal方法：当前对象作为（附加）第一个参数自动传递classmethod：当前对象的类自动作为（附加的）第一个参数传递staticmethod：不会自动传递额外的参数。传递给函数的就是得到的。

更详细地说。。。

正常方法

“标准”方法，如在所有面向对象的语言中。当调用对象的方法时，会自动为其提供一个额外的参数self作为其第一个参数。即，方法

def f(self, x, y)

必须使用2个参数调用。self是自动传递的，它是对象本身。类似于这个神奇地出现在例如java/c++中，只有在python中才显式显示。

实际上，第一个参数不必称为self，但它是标准的约定，所以请保留它

类方法

装饰方法时

@classmethod
def f(cls, x, y)

自动提供的参数不是self，而是self的类。

静态法

装饰方法时

@staticmethod
def f(x, y)

该方法根本没有给出任何自动参数。它只提供调用它的参数。

用法

classmethod主要用于替代构造函数。staticmethod不使用对象的状态，甚至不使用类本身的结构。它可以是类外部的函数。它只放在类中，用于对具有类似功能的函数进行分组（例如，像Java的Math类静态方法）

class Point
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    def frompolar(cls, radius, angle):
        """The `cls` argument is the `Point` class itself"""
        return cls(radius * cos(angle), radius * sin(angle))

    @staticmethod
    def angle(x, y):
        """this could be outside the class, but we put it here 
just because we think it is logically related to the class."""
        return atan(y, x)


p1 = Point(3, 2)
p2 = Point.frompolar(3, pi/4)

angle = Point.angle(3, 2)