当然，类定义了一组实例。类的方法作用于单个实例。类方法(和变量)用于将与实例集相关的其他信息挂起。

例如，如果你的类定义了一组学生，你可能想要类变量或方法来定义学生可以成为成员的年级集。

您还可以使用类方法定义用于处理整个集合的工具。例如，Student.all_of_em()可能返回所有已知的学生。显然，如果您的实例集具有比集合更多的结构，您可以提供类方法来了解该结构。Students.all_of_em(等级=“下属”)

这样的技术往往会导致将实例集的成员存储到植根于类变量的数据结构中。这时，您需要注意避免使垃圾收集受挫。

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

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

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

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

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

我以前用过PHP，最近我在问自己，这个类方法是怎么回事?Python手册是非常技术性的，非常简短的文字，所以它不会帮助理解这个功能。我一直在谷歌上搜索，然后我找到了答案——> http://code.anjanesh.net/2007/12/python-classmethods.html。

如果你懒得点击它。我的解释很简短。：）

在PHP中(也许不是所有人都知道PHP，但是这个语言非常直接，每个人都应该明白我在说什么)，我们有这样的静态变量:

class A
{

    static protected $inner_var = null;

    static public function echoInnerVar()
    {
        echo self::$inner_var."\n";
    }

    static public function setInnerVar($v)
    {
        self::$inner_var = $v;
    }

}

class B extends A
{
}

A::setInnerVar(10);
B::setInnerVar(20);

A::echoInnerVar();
B::echoInnerVar();

在这两种情况下，输出都是20。

但是在python中，我们可以添加@classmethod装饰器，这样就可以分别输出10和20。例子:

class A(object):
    inner_var = 0

    @classmethod
    def setInnerVar(cls, value):
        cls.inner_var = value

    @classmethod
    def echoInnerVar(cls):
        print cls.inner_var


class B(A):
    pass


A.setInnerVar(10)
B.setInnerVar(20)

A.echoInnerVar()
B.echoInnerVar()

聪明,不是吗?

如果你不是一个“训练有素的程序员”，这应该会有帮助:

我想我已经理解了上面和网上其他地方的技术解释，但我总是有一个问题:“不错，但我为什么需要它?”什么是实际的用例?”现在生活给了我一个很好的例子来阐明一切:

我使用它来控制由多线程模块实例化的类的实例之间共享的全局共享变量。在人性化的语言中，我正在运行多个代理，为深度学习并行创建示例。(想象多个玩家同时玩ATARI游戏，每个人都将他们的游戏结果保存到一个公共存储库(SHARED VARIABLE))

我用以下代码实例化玩家/代理(在主/执行代码中):

a3c_workers = [A3C_Worker(self.master_model, self.optimizer, i, self.env_name, self.model_dir) for i in range(multiprocessing.cpu_count())]

它创造了和我的电脑上有多少处理器核心一样多的玩家 A3C_Worker——定义代理的类 A3c_workers -是该类实例的列表(即每个实例都是一个玩家/代理)

现在我想知道所有玩家/代理玩了多少游戏，因此在A3C_Worker定义中，我定义了所有实例共享的变量:

class A3C_Worker(threading.Thread):
   global_shared_total_episodes_across_all_workers = 0

现在，当工人们完成他们的游戏时，每完成一场比赛，他们都会增加1个数字

在我的示例生成结束时，我关闭了实例，但共享变量已经分配了所玩游戏的总数。所以当我重新运行它时，我最初的总集数是之前的总和。但是我需要这个计数来代表每次单独运行的值

为了解决这个问题，我指定:

class A3C_Worker(threading.Thread):
    @classmethod
    def reset(cls):
        A3C_Worker.global_shared_total_episodes_across_all_workers = 0

在执行代码中调用:

A3C_Worker.reset()

注意，它是对CLASS整体的调用，而不是它单独的任何实例。因此，从现在开始，对于我发起的每个新代理，它将把我的计数器设置为0。

使用通常的方法定义def play(self):，将需要我们为每个实例单独重置计数器，这将需要更多的计算，并且难以跟踪。

我认为最明确的答案是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()时，您可以消除这个问题，并且两个复制函数可以并排使用。