也许有点示例代码将有助于：发现其中的差别在调用签名foo，class_foo并且static_foo：

class A(object):
    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    

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只是一个函数，但是当你调用a.foo它时，不仅获得该函数，还会获得该函数的“部分应用”版本，该对象实例a绑定为该函数的第一个参数。foo期望有2个参数，而a.foo只期望有1个参数。

a与foo绑定。这就是下面“绑定”一词的含义：

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

与a.class_foo，a不绑定class_foo，而是与类A绑定class_foo。

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

在这里，使用静态方法，即使它是一种方法，也a.static_foo只返回一个没有参数绑定的良好的'ole函数。static_foo期望有1个参数，也 a.static_foo期望有1个参数。

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

当然，当你static_foo使用类进行调用时，也会发生同样的事情A。

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

一个静态方法是一无所知，它被称为上类或实例的方法。它只是获取传递的参数，没有隐式的第一个参数。它在Python中基本上是没有用的-你可以只使用模块函数而不是静态方法。

甲类方法，在另一方面，是获取传递的类，它被称为上，或该类的实例，它被称为上的，作为第一个参数的方法。当你希望该方法成为类的工厂时，这很有用：由于它获得了作为第一个参数调用的实际类，因此即使涉及子类，也始终可以实例化正确的类。例如dict.fromkeys()，观察在子类上调用时，类方法如何返回子类的实例：

>>> class DictSubclass(dict):
...     def __repr__(self):
...         return "DictSubclass"
... 
>>> dict.fromkeys("abc")
{'a': None, 'c': None, 'b': None}
>>> DictSubclass.fromkeys("abc")
DictSubclass
>>>