诚实?我从未发现staticmethod或classmethod的用途。我还没有看到一个操作不能使用全局函数或实例方法来完成。

如果python像Java那样使用private和protected成员，情况将有所不同。在Java中，我需要一个静态方法来访问实例的私有成员来做一些事情。在Python中，很少需要这样做。

通常，我看到人们使用静态方法和类方法，而他们真正需要做的只是更好地使用python的模块级名称空间。

我从Ruby学到的是，所谓的类方法和所谓的实例方法只是一个函数，它的第一个参数具有语义意义，当函数作为对象的方法(即obj.meth())调用时，该参数会被无声地传递。

通常，该对象必须是一个实例，但@classmethod方法装饰器更改规则以传递一个类。你可以在一个实例上调用一个类方法(它只是一个函数)-第一个参数将是它的类。

因为它只是一个函数，所以在任何给定的作用域(即类定义)中只能声明一次。因此，对于ruby开发者来说，你不能让一个类方法和一个实例方法同名。

考虑一下:

class Foo():
  def foo(x):
    print(x)

你可以在实例上调用foo

Foo().foo()
<__main__.Foo instance at 0x7f4dd3e3bc20>

但不是在课堂上:

Foo.foo()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method foo() must be called with Foo instance as first argument (got nothing instead)

现在添加@classmethod:

class Foo():
  @classmethod
  def foo(x):
    print(x)

调用一个实例现在会通过它的类:

Foo().foo()
__main__.Foo

调用类也一样:

Foo.foo()
__main__.Foo

按照惯例，我们在实例方法中使用self作为第一个参数，在类方法中使用cls。我在这里用这两个都不是来说明它只是一个论点。在Ruby中，self是一个关键字。

与Ruby的对比:

class Foo
  def foo()
    puts "instance method #{self}"
  end
  def self.foo()
    puts "class method #{self}"
  end
end

Foo.foo()
class method Foo

Foo.new.foo()
instance method #<Foo:0x000000020fe018>

Python类方法只是一个装饰函数，您可以使用相同的技术来创建自己的装饰器。修饰过的方法包装了真正的方法(在@classmethod的情况下，它传递了额外的类参数)。底层的方法仍然存在，隐藏但仍然可以访问。

脚注:在类和实例方法之间的名称冲突引起了我的好奇心之后，我写了这篇文章。我不是Python专家，如果有任何错误，我希望得到评论。

当用户登录我的网站时，user()对象从用户名和密码实例化。

如果我需要一个没有用户在那里登录的用户对象(例如，一个管理用户可能想要删除另一个用户帐户，所以我需要实例化该用户并调用它的delete方法):

我有类方法来获取用户对象。

class User():
    #lots of code
    #...
    # more code

    @classmethod
    def get_by_username(cls, username):
        return cls.query(cls.username == username).get()

    @classmethod
    def get_by_auth_id(cls, auth_id):
        return cls.query(cls.auth_id == auth_id).get()

这是一个有趣的话题。我对它的理解是，python的classmethod操作起来像一个单例而不是一个工厂(它返回一个类的生成实例)。它是单例的原因是存在一个公共对象(字典)，但只为类生成一次，但由所有实例共享。

为了说明这一点，这里有一个例子。注意，所有实例都有一个对单个字典的引用。这不是我理解的工厂模式。这可能是python独有的。

class M():
 @classmethod
 def m(cls, arg):
     print "arg was",  getattr(cls, "arg" , None),
     cls.arg = arg
     print "arg is" , cls.arg

 M.m(1)   # prints arg was None arg is 1
 M.m(2)   # prints arg was 1 arg is 2
 m1 = M()
 m2 = M() 
 m1.m(3)  # prints arg was 2 arg is 3  
 m2.m(4)  # prints arg was 3 arg is 4 << this breaks the factory pattern theory.
 M.m(5)   # prints arg was 4 arg is 5

类方法用于当您需要不特定于任何特定实例，但仍以某种方式涉及类的方法时。最有趣的是，它们可以被子类覆盖，这在Java的静态方法或Python的模块级函数中是不可能的。

如果你有一个类MyClass，和一个模块级的函数，它操作MyClass(工厂，依赖注入存根等)，让它成为一个类方法。然后它将可用于子类。

我也问过自己几次同样的问题。尽管这里的人试图努力解释它，恕我直言，我找到的最好的答案(也是最简单的)答案是Python文档中对Class方法的描述。

还有对静态方法的引用。如果有人已经知道实例方法(我假设是这样)，这个答案可能是把它们放在一起的最后一块……

关于这个主题的进一步和更深入的阐述也可以在文档中找到: 标准类型层次结构(向下滚动到实例方法部分)