您可能需要考虑以下两者之间的区别：

class A:
    def foo():  # no self parameter, no decorator
        pass

and

class B:
    @staticmethod
    def foo():  # no self parameter
        pass

这在python2和python3之间发生了变化：

蟒蛇2:

>>> A.foo()
TypeError
>>> A().foo()
TypeError
>>> B.foo()
>>> B().foo()

蟒蛇3：

>>> A.foo()
>>> A().foo()
TypeError
>>> B.foo()
>>> B().foo()

因此，在python3中，对仅直接从类调用的方法使用@staticmethod已成为可选的。如果要从类和实例调用它们，仍然需要使用@staticmethoddecorator。

其他案例都被未用的答案很好地涵盖了。

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

您可能需要考虑以下两者之间的区别：

class A:
    def foo():  # no self parameter, no decorator
        pass

and

class B:
    @staticmethod
    def foo():  # no self parameter
        pass

这在python2和python3之间发生了变化：

蟒蛇2:

>>> A.foo()
TypeError
>>> A().foo()
TypeError
>>> B.foo()
>>> B().foo()

蟒蛇3：

>>> A.foo()
>>> A().foo()
TypeError
>>> B.foo()
>>> B().foo()

因此，在python3中，对仅直接从类调用的方法使用@staticmethod已成为可选的。如果要从类和实例调用它们，仍然需要使用@staticmethoddecorator。

其他案例都被未用的答案很好地涵盖了。

从其文档中定义静态方法和类方法。以及何时使用静态方法和何时使用类方法。

静态方法类似于java和C#中的静态方法，它不会使用类的任何初始化值，只需要从外部进行操作即可。类方法：通常用于继承重写，当我们重写一个方法时，然后使用CLS实例来判断是否要调用子类或父类的方法。以防您希望同时使用同名和不同签名的方法。

静态方法（函数）->方法

Convert a function to be a static method.

A static method does not receive an implicit first argument.
To declare a static method, use this idiom:

     class C:
         @staticmethod
         def f(arg1, arg2, ...):
             ...

It can be called either on the class (e.g. C.f()) or on an instance
(e.g. C().f()).  The instance is ignored except for its class.

Static methods in Python are similar to those found in Java or C++.
For a more advanced concept, see the classmethod builtin.
"""

classmethod（函数）->方法

Convert a function to be a class method.

A class method receives the class as implicit first argument,
just like an instance method receives the instance.
To declare a class method, use this idiom:

  class C:
      @classmethod
      def f(cls, arg1, arg2, ...):
          ...

It can be called either on the class (e.g. C.f()) or on an instance
(e.g. 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 methods are different than C++ or Java static methods.
If you want those, see the staticmethod builtin.

我认为提供一个纯Python版本的staticmethod和classmethod将有助于在语言级别上理解它们之间的区别（请参阅Descriptor Howto Guide）。

这两个都是非数据描述符（如果您首先熟悉描述符，那么更容易理解它们）。

class StaticMethod(object):
    "Emulate PyStaticMethod_Type() in Objects/funcobject.c"

    def __init__(self, f):
        self.f = f

    def __get__(self, obj, objtype=None):
        return self.f


class ClassMethod(object):
    "Emulate PyClassMethod_Type() in Objects/funcobject.c"
    def __init__(self, f):
        self.f = f

    def __get__(self, obj, cls=None):
        def inner(*args, **kwargs):
            if cls is None:
                cls = type(obj)
            return self.f(cls, *args, **kwargs)
        return inner

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

假设有两个类——父类和子类。如果要使用@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()