python @classmethod和@staticmethod区别

python 类方法和静态方法区别

python @classmethod和@staticmethod区别

Python中至少有三种比较常见的方法类型，即实例方法，类方法、静态方法。它们是如何定义的呢？如何调用的呢？它们又有何区别和作用呢？且看下文。

首先，这三种方法都定义在类中。下面我先简单说一下怎么定义和调用的。（PS：实例对象的权限最大。）

实例方法

定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；

调用：只能由实例对象调用。

类方法

定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，通过它来传递类的属性和方法（不能传实例的属性和方法）；

调用：实例对象和类对象都可以调用。

静态方法

定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；

调用：实例对象和类对象都可以调用。

类方法

使用装饰器@classmethod。

原则上，类方法是将类本身作为对象进行操作的方法。假设有个方法，且这个方法在逻辑上采用类本身作为对象来调用更合理，那么这个方法就可以定义为类方法。另外，如果需要继承，也可以定义为类方法。

如下场景：

假设我有一个学生类和一个班级类，想要实现的功能为：
    执行班级人数增加的操作、获得班级的总人数；
    学生类继承自班级类，每实例化一个学生，班级人数都能增加；
    最后，我想定义一些学生，获得班级中的总人数。

思考：这个问题用类方法做比较合适，为什么？因为我实例化的是学生，但是如果我从学生这一个实例中获得班级总人数，在逻辑上显然是不合理的。同时，如果想要获得班级总人数，如果生成一个班级的实例也是没有必要的。

class ClassTest(object):
    __num = 0

    @classmethod
    def addNum(cls):
        cls.__num += 1

    @classmethod
    def getNum(cls):
        return cls.__num

    # 这里我用到魔术方法__new__，主要是为了在创建实例的时候调用累加方法。
    def __new__(self):
        ClassTest.addNum()
        return super(ClassTest, self).__new__(self)

class Student(ClassTest):
    def __init__(self):
        self.name = ''

a = Student()
b = Student()
print(ClassTest.getNum())

静态方法

使用装饰器@staticmethod。

静态方法是类中的函数，不需要实例。静态方法主要是用来存放逻辑性的代码，逻辑上属于类，但是和类本身没有关系，也就是说在静态方法中，不会涉及到类中的属性和方法的操作。可以理解为，静态方法是个独立的、单纯的函数，它仅仅托管于某个类的名称空间中，便于使用和维护。

譬如，我想定义一个关于时间操作的类，其中有一个获取当前时间的函数。

import time

class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S", time.localtime())

print(TimeTest.showTime())
t = TimeTest(2, 10, 10)
nowTime = t.showTime()
print(nowTime)

如上，使用了静态方法（函数），然而方法体中并没使用（也不能使用）类或实例的属性（或方法）。若要获得当前时间的字符串时，并不一定需要实例化对象，此时对于静态方法而言，所在类更像是一种名称空间。

其实，我们也可以在类外面写一个同样的函数来做这些事，但是这样做就打乱了逻辑关系，也会导致以后代码维护困难。

类方法里面可以操作：类方法，静态方法，实例方法

静态方法里面可以操作：类方法，静态方法，实例方法

class Foo(object):
    X = 1
    Y = 2

    def obj_func(self):
        print('我是一个实例方法')
        return '我是一个实例方法,我将被类方法，静态方法调用'

    @staticmethod
    def averag(*mixes):
        foo1 = Foo()
        foo1.obj_func()
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # 在静态方法中调用静态方法
        print("在静态方法中调用静态方法")
        return Foo.averag(Foo.X, Foo.Y)

    @staticmethod
    def static_method1():
        print("在静态方法中调用类方法")
        return Foo.class_method0()

    @classmethod
    def class_method0(cls):
        print("我是一个类方法：classmethod, 我将被静态方法调用")
        foo2 = Foo()
        return foo2.obj_func()

    @classmethod
    def class_method1(cls):  # 在类方法中使用静态方法
        print("在类方法中使用静态方法")
        return cls.averag(cls.X, cls.Y)

foo = Foo()
print(foo.static_method1())
print('*****************************')
print(foo.class_method1())

输出：

在静态方法中调用类方法
我是一个类方法：classmethod, 我将被静态方法调用
我是一个实例方法
我是一个实例方法,我将被类方法，静态方法调用
*****************************
在类方法中使用静态方法
我是一个实例方法
1.5

class Test(object):
    def InstanceFun(self):
        print("InstanceFun")
        print(self)

    @classmethod
    def ClassFun(cls):
        print("ClassFun")
        print(cls)

    @staticmethod
    def StaticFun():
        print("StaticFun")
        t = Test()
        t.InstanceFun()　　　# 输出InstanceFun，打印对象内存地址“<__main__.Test object at 0x0293DCF0>”
        Test.ClassFun()     # 输出ClassFun，打印类位置 <class '__main__.Test'>
        Test.StaticFun()    # 输出StaticFun
        t.StaticFun()       # 输出StaticFun
        t.ClassFun()         # 输出ClassFun，打印类位置 <class '__main__.Test'>
        Test.InstanceFun()    # 错误，TypeError: unbound method instanceFun() must be called with Test             instance as first argument
        Test.InstanceFun(t)   # 输出InstanceFun，打印对象内存地址“<__main__.Test object at 0x0293DCF0>”
        t.ClassFun(Test)      # 错误   classFun() takes exactly 1 argument (2 given)

继承类中的区别

从下面代码可以看出，如果子类继承父类的方法，子类覆盖了父类的静态方法，
子类的实例继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。
子类的实例继承了父类的class_method类方法，调用该方法，调用的是子类的方法和子类的类属性。

class Foo(object):
    X = 1
    Y = 14

    @staticmethod
    def averag(*mixes):  # "父类中的静态方法"
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # "父类中的静态方法"
        print "父类中的静态方法"
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):  # 父类中的类方法
        print "父类中的类方法"
        return cls.averag(cls.X, cls.Y)

class Son(Foo):
    X = 3
    Y = 5

    @staticmethod
    def averag(*mixes):  # "子类中重载了父类的静态方法"
        print "子类中重载了父类的静态方法"
        print "666 ",mixes
        return sum(mixes) / 3

p = Son()
print "result of p.averag(1,5)"
print (p.averag(1,5))
print "result of p.static_method()"
print(p.static_method())
print "result of p.class_method()"
print(p.class_method())

输出：

result of p.averag(1,5)
子类中重载了父类的静态方法
666  (1, 5)
2
result of p.static_method()
父类中的静态方法
7
result of p.class_method()
父类中的类方法
子类中重载了父类的静态方法
666  (3, 5)
2

classmethod与staticmethod

这两个方法的用法是类似的，在上面的例子中大多数情况下，classmethod也可以通过staticmethod代替，在通过类调用时，这两者对于调用者来说是不可区分的。

这两者的区别在于，classmethod增加了一个对实际调用类的引用，这带来了很多方便的地方：

1. 方法可以判断出自己是通过基类被调用，还是通过某个子类被调用
2. 通过子类调用时，方法可以返回子类的实例而非基类的实例
3. 通过子类调用时，方法可以调用子类的其他classmethod

一般来说classmethod可以完全替代staticmethod。staticmethod唯一的好处是调用时它返回的是一个真正的函数，而且每次调用时返回同一个实例（classmethod则会对基类和子类返回不同的bound method实例），但这点几乎从来没有什么时候是有用的。不过，staticmethod可以在子类上被重写为classmethod，反之亦然，因此也没有必要提前将staticmethod全部改为classmethod，按需要使用即可。