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

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

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

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

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没有任何隐式参数。

@python2.4中添加了修饰符。如果您使用的是python<2.4，则可以使用classmethod（）和staticmethod（）函数。

例如，如果您想要创建一个工厂方法（一个函数，它返回一个类的不同实现的实例，具体取决于它获得的参数），您可以执行以下操作：

class Cluster(object):

    def _is_cluster_for(cls, name):
        """
        see if this class is the cluster with this name
        this is a classmethod
        """ 
        return cls.__name__ == name
    _is_cluster_for = classmethod(_is_cluster_for)

    #static method
    def getCluster(name):
        """
        static factory method, should be in Cluster class
        returns a cluster object for the given name
        """
        for cls in Cluster.__subclasses__():
            if cls._is_cluster_for(name):
                return cls()
    getCluster = staticmethod(getCluster)

还要注意，这是一个使用类方法和静态方法的好例子，静态方法显然属于类，因为它在内部使用了类Cluster。类方法只需要关于类的信息，而不需要对象的实例。

将_is_cluster_for方法设置为类方法的另一个好处是，子类可以决定更改其实现，这可能是因为它非常通用，可以处理多种类型的集群，因此仅检查类的名称是不够的。

要决定是使用@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

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

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

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

也许一些示例代码会有所帮助：注意foo、class_foo和static_foo的调用签名的不同：

class A(object):
    def foo(self, x):
        print(f"executing foo({self}, {x})")

    @classmethod
    def class_foo(cls, x):
        print(f"executing class_foo({cls}, {x})")

    @staticmethod
    def static_foo(x):
        print(f"executing static_foo({x})")

a = A()

下面是对象实例调用方法的常用方法。对象实例a作为第一个参数隐式传递。

a.foo(1)
# executing foo(<__main__.A object at 0xb7dbef0c>, 1)

使用classmethods，对象实例的类作为第一个参数而不是self隐式传递。

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

也可以使用类调用class_foo。事实上，如果你定义了类方法，这可能是因为您打算从类而不是从类实例调用它。A.foo（1）会引发TypeError，但A.class_foo（1）工作正常：

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

人们发现类方法的一个用途是创建可继承的替代构造函数。

使用staticmethods，self（对象实例）和cls（类）都不会作为第一个参数隐式传递。它们的行为类似于普通函数，只是您可以从实例或类调用它们：

a.static_foo(1)
# executing static_foo(1)

A.static_foo('hi')
# executing static_foo(hi)

静态方法用于将与类有某种逻辑联系的函数分组到该类。

foo只是一个函数，但当你调用.foo时，你不只是得到函数，您将得到函数的“部分应用”版本，其中对象实例a作为函数的第一个参数。foo需要2个参数，而a.foo只需要1个参数。

a绑定到foo。这就是以下术语“约束”的含义：

print(a.foo)
# <bound method A.foo of <__main__.A object at 0xb7d52f0c>>

对于.class_foo，a不绑定到class_foo，而类a绑定到class-foo。

print(a.class_foo)
# <bound method type.class_foo of <class '__main__.A'>>

这里，对于staticmethod，即使它是一个方法，a.static_foo也只返回一个没有参数约束的好的ole函数。static_foo需要1个参数，并且.static_foo也需要1个参数。

print(a.static_foo)
# <function static_foo at 0xb7d479cc>

当然，当用类A调用static_foo时也会发生同样的情况。

print(A.static_foo)
# <function static_foo at 0xb7d479cc>