静态方法和类方法

先看下面的代码

#!/usr/bin/env python
#coding:utf-8

class Foo(object):        #Python 3: class Foo:
    one = 0

    def __init__(self):
        Foo.one = Foo.one + 1

def get_class_attr(cls):
    return cls.one

if __name__ == "__main__":
    f1 = Foo()
    print "f1:",Foo.one        #Python 3: print("f1:"+str(Foo.one))，下同，从略
    f2 = Foo()
    print "f2:",Foo.one

    print get_class_attr(Foo)

在上述代码中，有一个函数get_class_attr()，这个函数的参数我用cls，从函数体的代码中看，要求它引用的对象应该具有属性one，这就说明，不是随便一个对象就可以的。恰好，就是这么巧，我在前面定义的类Foo中，就有one这个属性。于是乎，我在调用这个函数的时候，就直接将该类对象传给了它get_class_attr(Foo)。

其运行结果如下：

f1: 1
f2: 2
2

在这个程序中，函数get_class_attr()写在了类的外面，但事实上，函数只能调用前面写的那个类对象，因为不是所有对象都有那个特别的属性的。所以，这种写法，使得类和函数的耦合性太强了，不便于以后维护。这种写法是应该避免的。避免的方法就是把函数与类融为一体。于是就有了下面的写法。

#!/usr/bin/env python
#coding:utf-8

class Foo(object):    #Python 3: class Foo:
    one = 0

    def __init__(self):
        Foo.one = Foo.one + 1

    @classmethod
    def get_class_attr(cls):
        return cls.one

if __name__ == "__main__":
    f1 = Foo()
    print "f1:",Foo.one
    f2 = Foo()
    print "f2:",Foo.one

    print f1.get_class_attr()
    print "f1.one",f1.one
    print Foo.get_class_attr()

    print "*"* 10
    f1.one = 8
    Foo.one = 9
    print f1.one
    print f1.get_class_attr()
    print Foo.get_class_attr()

在这个程序中，出现了@classmethod——装饰器——在函数那部分遇到过了。需要注意的是@classmethod所装饰的方法的参数中，第一个参数不是self，这是和我们以前看到的类中的方法是有区别的。这里我使用了参数cls，你用别的也可以，只不过习惯用cls。

再看对类的使用过程。先贴出上述程序的执行结果：

f1: 1
f2: 2
2
f1.one 2
2
**********
8
9
9

分别建立两个实例，此后类属性Foo.one的值是2，然后分别通过实例和类来调用get_class_attr()方法（没有显示写cls参数），结果都相同。

当修改类属性和实例属性，再次通过实例和类调用get_class_attr()方法，得到的依然是类属性的结果。这说明，装饰器@classmethod所装饰的方法，其参数cls引用的对象是类对象Foo。

至此，可以下一个定义了。

所谓类方法，就是在类里面定义的方法，该方法由装饰器@classmethod所装饰，其第一个参数cls所引用的是这个类对象，即将类本身作为引用对象传入到此方法中。

理解了类方法之后，用同样的套路理解另外一个方法——静态方法。还是先看代码——一个有待优化的代码。

#!/usr/bin/env python
#coding:utf-8

T = 1

def check_t():
    T = 3
    return T 

class Foo(object):        #Python 3: class Foo:
    def __init__(self,name):
        self.name = name

    def get_name(self):
        if check_t():
            return self.name
        else:
            return "no person"

if __name__ == "__main__":
    f = Foo("canglaoshi")
    name = f.get_name()
    print name        #Python 3: print(name)

先观察上面的程序，发现在类Foo里面使用了外面定义的函数check_t()。这种类和函数的关系，也是由于有密切关系，从而导致程序维护有困难，于是在和前面同样的理由之下，就出现了下面比较便于维护的程序。

#!/usr/bin/env python
#coding:utf-8

T = 1

class Foo(object):        #Python 3: class Foo:
    def __init__(self,name):
        self.name = name

    @staticmethod
    def check_t():
        T = 1
        return T

    def get_name(self):
        if self.check_t():       
            return self.name
        else:
            return "no person"

if __name__ == "__main__":
    f = Foo("canglaoshi")
    name = f.get_name()
    print name        #Python 3: print(name)

经过优化，将原来放在类外面的函数，移动到了类里面，也就是函数check_t()现在位于类Foo的命名空间之内了。但是，不是简单的移动，还要在这个函数的前面加上@staticmethod装饰器，并且要注意的是，虽然这个函数位于类的里面，跟其它的方法不同，它不以self为第一个参数。当使用它的时候，可以通过实例调用，比如self.check_t()；也可以通过类调用这个方法，比如Foo.check_t()。

从上面的程序可以看出，尽管check_t()位于类的命名空间之内，它却是一个独立的方法，跟类没有什么关系，仅仅是为了免除前面所说的维护上的困难，写在类的作用域内的普通函数罢了。但，它的存在也是有道理的，以上的例子就是典型说明。当然，在类的作用域里面的时候，前面必须要加上一个装饰器@staticmethod。我们将这种方法也给予命名，称之为静态方法。

方法，是类的重要组成部分。本节专门讲述了方法中的几种特殊方法，它们为我们使用类的方法提供了更多便利的工具。但是，类的重要特征之一——继承，还没有亮相。