我从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专家，如果有任何错误，我希望得到评论。

我从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专家，如果有任何错误，我希望得到评论。

替代构造函数是经典的例子。

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

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

我认为最明确的答案是AmanKow的答案。归根结底，这取决于你想如何组织你的代码。你可以把所有东西都写成模块级的函数，这些函数被包装在模块的命名空间中

module.py (file 1)
---------
def f1() : pass
def f2() : pass
def f3() : pass


usage.py (file 2)
--------
from module import *
f1()
f2()
f3()
def f4():pass 
def f5():pass

usage1.py (file 3)
-------------------
from usage import f4,f5
f4()
f5()

上面的过程代码组织得不好，正如你所看到的，只有3个模块后，它变得令人困惑，每个方法是做什么的?你可以为函数使用较长的描述性名称(如在java中)，但你的代码仍然很快变得难以管理。

面向对象的方法是将代码分解为可管理的块，即类和对象，函数可以与对象、实例或类相关联。

与模块级函数相比，使用类函数可以在代码中获得另一个级别的除法。 因此，您可以在类中对相关函数进行分组，使它们更特定于分配给该类的任务。例如，你可以创建一个文件工具类:

class FileUtil ():
  def copy(source,dest):pass
  def move(source,dest):pass
  def copyDir(source,dest):pass
  def moveDir(source,dest):pass

//usage
FileUtil.copy("1.txt","2.txt")
FileUtil.moveDir("dir1","dir2")

这种方式更灵活，更可维护，您将函数分组在一起，并且每个函数的功能更明显。此外，您还可以防止名称冲突，例如，函数副本可能存在于您在代码中使用的另一个导入模块中(例如网络副本)，因此当您使用全名FileUtil.copy()时，您可以消除这个问题，并且两个复制函数可以并排使用。

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

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

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