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

我以前用过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()

聪明,不是吗?

它允许您编写可与任何兼容类一起使用的泛型类方法。

例如:

@classmethod
def get_name(cls):
    print cls.name

class C:
    name = "tester"

C.get_name = get_name

#call it:
C.get_name()

如果你不使用@classmethod，你可以用self关键字来做，但它需要一个Class的实例:

def get_name(self):
    print self.name

class C:
    name = "tester"

C.get_name = get_name

#call it:
C().get_name() #<-note the its an instance of class C

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

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

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

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

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

所以我使用类变量和@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()

@classmethod对于从外部资源轻松实例化该类的对象非常有用。考虑以下几点:

import settings

class SomeClass:
    @classmethod
    def from_settings(cls):
        return cls(settings=settings)

    def __init__(self, settings=None):
        if settings is not None:
            self.x = settings['x']
            self.y = settings['y']

然后在另一个文件中:

from some_package import SomeClass

inst = SomeClass.from_settings()

访问inst.x将得到与settings['x']相同的值。