Python中的@classmethod @staticmethod区别

Python中3种方式定义类方法, 常规方式, @classmethod修饰方式, @staticmethod修饰方式.

class A(object):
    b = '666666'
    def __init__(self, device):
        self.device = device
    def foo(self, x):
        print("executing foo(%s,%s)" % (self, x))
        print('普通方法获取实例属性 %s'%self.device)
        print('普通方法获取类属性 %s'%self.b)
        print('self:', self)
    @classmethod
    def class_foo(cls, x):
        print("executing class_foo(%s,%s)" % (cls, x))
        print('cls:', cls)
        print('类方法中获取类属性 %s'%cls.b)

    @staticmethod
    def static_foo(x):
        print("executing static_foo(%s)" % x)
        print('静态方法中获取类属性 %s'%A.b)

if __name__ == '__main__':
    a = A('123456789')
    a.foo('a')
    print('-'*50)
    a.class_foo('b')
    print('-'*50)

    a.static_foo('c')
    print('-'*50)

    # A.foo('a')
    A.class_foo('b')
    print('-'*50)
    A.static_foo('c')

运行结果

executing foo(<__main__.A object at 0x0000014D269EB580>,a)
普通方法获取实例属性 123456789
普通方法获取类属性 666666
self: <__main__.A object at 0x0000014D269EB580>
--------------------------------------------------
executing class_foo(<class '__main__.A'>,b)
cls: <class '__main__.A'>
类方法中获取类属性 666666
--------------------------------------------------
executing static_foo(c)
静态方法中获取类属性 666666
--------------------------------------------------
executing class_foo(<class '__main__.A'>,b)
cls: <class '__main__.A'>
类方法中获取类属性 666666
--------------------------------------------------
executing static_foo(c)
静态方法中获取类属性 666666

1.定义方式

普通的类方法foo()需要通过self参数隐式的传递当前类对象的实例。 @classmethod修饰的方法class_foo()需要通过cls参数传递当前类对象。@staticmethod修饰的方法定义与普通函数是一样的。

self和cls的区别不是强制的，只是PEP8中一种编程风格，slef通常用作实例方法的第一参数，cls通常用作类方法的第一参数。即通常用self来传递当前类对象的实例，cls传递当前类对象。

2.绑定对象

foo方法绑定对象A的实例，class_foo方法绑定对象A，static_foo没有参数绑定。
>>> print(a.foo)
<bound method A.foo of <__main__.A object at 0x0278B170>>
>>> print(a.class_foo)
<bound method A.class_foo of <class '__main__.A'>>
>>> print(a.static_foo)
<function A.static_foo at 0x02780390>

3.调用方式

foo可通过实例a调用，类对像A直接调用会参数错误。

>>> a.foo(1)
executing foo(<__main__.A object at 0x0278B170>,1)
self: <__main__.A object at 0x0278B170>
>>> A.foo(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() missing 1 required positional argument: 'x'

但foo如下方式可以使用正常，显式的传递实例参数a。

>>> A.foo(a, 1)
executing foo(<__main__.A object at 0x0278B170>,1)
self: <__main__.A object at 0x0278B170>

class_foo通过类对象或对象实例调用。

>>> A.class_foo(1)
executing class_foo(<class '__main__.A'>,1)
cls: <class '__main__.A'>
>>> a.class_foo(1)
executing class_foo(<class '__main__.A'>,1)
cls: <class '__main__.A'>

static_foo通过类对象或对象实例调用。

>>> A.static_foo(1)
executing static_foo(1)
>>> a.static_foo(1)
executing static_foo(1)

4.继承与覆盖普通类函数是一样的。

class B(A):
    pass
b = B()
b.foo(1)
b.class_foo(1)
b.static_foo(1)
# executing foo(<__main__.B object at 0x007027D0>,1)
# self: <__main__.B object at 0x007027D0>
# executing class_foo(<class '__main__.B'>,1)
# cls: <class '__main__.B'>
# executing static_foo(1)