python中@classmethod @staticmethod 的理解

清疚 2023-02-11 11:28 12阅读 0赞

Python中3种方式定义类方法,

*  常规方式，没有修饰
 *  `@classmethod`修饰方式. 类方法，能访问 类 数据成员
 *  `@staticmethod`修饰方式. 静态方法，不能访问类数据成员，不需要传递类参数`cls`或类的实例参数`self`

class A(object):
        def foo(self, x):
            print("executing foo(%s,%s)" % (self, x))
            print('self:', self)
        @classmethod
        def class_foo(cls, x):   # 类对象的方法
            print("executing class_foo(%s,%s)" % (cls, x))
            print('cls:', cls)
        @staticmethod
        def static_foo(x):  # 没有类对象参数 cls 或 类的实例对象参数 self
            print("executing static_foo(%s)" % x)    
    a = A()

## 1.定义方式 ##

*  `普通的类方法`foo()需要通过`self`参数隐式的传递当前类对象的实例。
 *  `@classmethod`修饰的方法class\_foo()需要通过cls参数传递当前`类对象`。`类对象`和`该类的实例对象`都可以访问这一**静态方法**。
 *  `@staticmethod`修饰的方法。定义与**普通函数**是一样的。不能直接访问类属性、类方法、实例属性、实例方法。因为根本没有传递`self`或`cls`参数给该方法。但是`类对象`和`该类的实例对象`都可以访问这一**静态方法**。

`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)  # 注意，a.foo(1) 等价于 A.foo(a, 1) ，显式的传递实例参数a
    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)

问题：`@staticmethod` 修饰的方法函数与普通的类外函数一样，为什么不直接使用普通函数？  
`@staticmethod` 是把函数嵌入到类中的一种方式，函数就属于类，同时表明函数不需要访问这个类。通过子类的继承覆盖，**能更好的组织代码**。