类方法提供了“语义糖”(不知道这个术语是否被广泛使用)——或者“语义便利”。

例如:你有一组表示对象的类。你可能想让类方法all()或find()写User.all()或User.find(firstname='Guido')。当然，这可以使用模块级函数来实现……

工厂方法(替代构造函数)确实是类方法的经典例子。

基本上，类方法适用于任何您希望有一个方法自然地适合类的名称空间，但不与类的特定实例相关联的时候。

例如，在excellent unipath模块中:

当前目录

Path.cwd () 返回实际的当前目录;例如,路径(“/ tmp / my_temp_dir”)。这是一个类方法。 .chdir () 使self为当前目录。

由于当前目录是进程范围的，cwd方法没有应该与之关联的特定实例。但是，将cwd更改为给定Path实例的目录确实应该是一个实例方法。

嗯…因为Path.cwd()确实返回了一个Path实例，我猜它可以被认为是一个工厂方法…

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

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

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

我最近想要一个非常轻量级的日志类，它可以根据可编程设置的日志级别输出不同数量的输出。但我不想每次输出调试消息、错误或警告时都实例化这个类。但是我还想封装这个日志记录工具的功能，并使其在不声明任何全局变量的情况下可重用。

所以我使用类变量和@classmethod装饰器来实现这一点。

使用简单的Logging类，我可以做到以下几点:

Logger._level = Logger.DEBUG

然后，在我的代码中，如果我想输出一堆调试信息，我就必须编写代码

Logger.debug( "this is some annoying message I only want to see while debugging" )

错误是可以改正的

Logger.error( "Wow, something really awful happened." )

在“生产”环境中，我可以指定

Logger._level = Logger.ERROR

现在，将只输出错误消息。调试消息将不会被打印。

这是我的班级:

class Logger :
    ''' Handles logging of debugging and error messages. '''

    DEBUG = 5
    INFO  = 4
    WARN  = 3
    ERROR = 2
    FATAL = 1
    _level = DEBUG

    def __init__( self ) :
        Logger._level = Logger.DEBUG

    @classmethod
    def isLevel( cls, level ) :
        return cls._level >= level

    @classmethod
    def debug( cls, message ) :
        if cls.isLevel( Logger.DEBUG ) :
            print "DEBUG:  " + message

    @classmethod
    def info( cls, message ) :
        if cls.isLevel( Logger.INFO ) :
            print "INFO :  " + message

    @classmethod
    def warn( cls, message ) :
        if cls.isLevel( Logger.WARN ) :
            print "WARN :  " + message

    @classmethod
    def error( cls, message ) :
        if cls.isLevel( Logger.ERROR ) :
            print "ERROR:  " + message

    @classmethod
    def fatal( cls, message ) :
        if cls.isLevel( Logger.FATAL ) :
            print "FATAL:  " + message

还有一些代码可以稍微测试一下:

def logAll() :
    Logger.debug( "This is a Debug message." )
    Logger.info ( "This is a Info  message." )
    Logger.warn ( "This is a Warn  message." )
    Logger.error( "This is a Error message." )
    Logger.fatal( "This is a Fatal message." )

if __name__ == '__main__' :

    print "Should see all DEBUG and higher"
    Logger._level = Logger.DEBUG
    logAll()

    print "Should see all ERROR and higher"
    Logger._level = Logger.ERROR
    logAll()

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

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

我使用它来控制由多线程模块实例化的类的实例之间共享的全局共享变量。在人性化的语言中，我正在运行多个代理，为深度学习并行创建示例。(想象多个玩家同时玩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):，将需要我们为每个实例单独重置计数器，这将需要更多的计算，并且难以跟踪。

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

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

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

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