Python实例方法、类方法与静态方法的定义及区别详解

1. 实例方法

在Python编程中，实例方法是使用频率最高且最为常见的方法类型。接下来我们将通过具体代码来了解其实例方法的实现细节。

class Kls(object):
    def __init__(self, data):
        self.data = data
    def printd(self):
        print(self.data)
ik1 = Kls('leo')
ik2 = Kls('lee')
ik1.printd()
ik2.printd()

运行结果如下：

leo lee

在上面的代码示例中，`printd`被定义为一个实例方法。其实例方法的第一个参数固定为`self`。当通过`ik1.printd()`调用该方法时，Python解释器会自动将调用该方法的实例`ik1`作为第一个参数传递给`self`。这使得`self`能够引用当前正在执行方法的实例对象。利用这一特性，上述代码成功输出了两个不同实例各自的成员数据。

2. 类方法

Python中定义类方法需要使用`@classmethod`装饰器。下面直接通过代码示例进行说明。

class Kls(object):
    num_inst = 0
    def __init__(self):
        Kls.num_inst = Kls.num_inst + 1
    @classmethod
    def get_no_of_instance(cls):
        return cls.num_inst
ik1 = Kls()
ik2 = Kls()
print (ik1.get_no_of_instance())
print (Kls.get_no_of_instance())

运行结果：

2 2

在上述示例中，我们的目标是统计类`Kls`创建的实例总数，因此定义了一个类变量`num_inst`来存储实例数量。通过应用`@classmethod`装饰器，方法 get_no_of_instance被明确定义为类方法。

当调用类方法时，Python会自动将类（即`class Kls`）作为第一个参数传递给`cls`。这使得在get_no_of_instance方法内部可以直接访问和引用类变量`num_inst`。

由于调用类方法时只需传入类本身，因此类方法既可以通过类名直接调用，也可以通过实例对象调用。

需要注意的是，实例方法只能通过实例对象进行调用，不能直接通过类名调用。

3. 静态方法

在实际开发中，经常需要定义一些与类相关但实现逻辑不依赖类或实例状态的方法。例如设置环境变量、修改其他类的变量等场景。此时，静态方法是合适的选择。

Python通过`@staticmethod`装饰器来定义静态方法。

IND = 'ON'
class Kls(object):
    def __init__(self, data):
        self.data = data
    @staticmethod
    def checkind():
        return IND == 'ON'
    def do_reset(self):
        if self.checkind():
            print('Reset done for: %s' % self.data)
    def set_db(self):
        if self.checkind():
            print('DB connection made for: %s' % self.data)
ik1 = Kls(24)
ik1.do_reset()
ik1.set_db()

运行结果：

Reset done for: 24 DB connection made for: 24

在代码中，我们定义了一个全局变量`IND`。由于该变量与类`Kls`的逻辑相关，因此将方法`checkind`定义在类`Kls`中。由于`checkind`仅需检查`IND`的值，无需引用类属性或实例属性，因此将其定义为静态方法。

对于静态方法，Python在调用时不会自动传递类或实例参数。因此，静态方法既可以通过类名调用，也可以通过实例对象调用。

4. 实例方法、类方法与静态方法的区别

下面通过代码对比展示实例方法、类方法和静态方法的具体区别。请注意观察代码中`foo`、`class_foo`和`static_foo`的定义方式及其调用方式。

'''
学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
class Kls(object):
    def foo(self, x):
        print('executing foo(%s,%s)' % (self, x))
    @classmethod
    def class_foo(cls,x):
        print('executing class_foo(%s,%s)' % (cls,x))
    @staticmethod
    def static_foo(x):
        print('executing static_foo(%s)' % x)
ik = Kls()
# 实例方法
ik.foo(1)
print(ik.foo)
print('==========================================')
# 类方法
ik.class_foo(1)
Kls.class_foo(1)
print(ik.class_foo)
print('==========================================')
# 静态方法
ik.static_foo(1)
Kls.static_foo('hi')
print(ik.static_foo)

运行结果：

executing foo(<__main__.Kls object at 0x0551E190>,1) <bound method Kls.foo of <__main__.Kls object at 0x0551E190>> ========================================== executing class_foo(<class '__main__.Kls'>,1) executing class_foo(<class '__main__.Kls'>,1) <bound method type.class_foo of <class '__main__.Kls'>> ========================================== executing static_foo(1) executing static_foo(hi) <function static_foo at 0x055238B0>

对于实例方法，调用时会将实例`ik`作为第一个参数传递给`self`。因此，当执行`ik.foo(1)`时，输出中包含了实例`ik`的内存地址信息。

对于类方法，调用时会将类`Kls`作为第一个参数传递给`cls`。因此，当执行`ik.class_foo(1)`时，输出显示了`Kls`类的类型信息。

前文提到，类方法既可以通过类调用也可以通过实例调用。在上述代码中，我们再次验证了这一点。

对于静态方法，调用时不需要传递类或实例参数。实际上，静态方法类似于在类外部定义的普通函数，区别仅在于静态方法可以通过类名或实例对象进行调用。

值得注意的是，在上面的示例中，`foo`本身只是一个函数。但当通过`ik.foo`调用时，我们得到的是一个已经与实例`ik`绑定的函数对象。直接调用`foo`需要两个参数，但调用`ik.foo`时只需一个参数。这是因为`foo`与`ik`发生了绑定，因此当我们打印`ik.foo`时，会看到以下输出：

<bound method Kls.foo of <__main__.Kls object at 0x0551E190>>

当调用`ik.class_foo`时，由于`class_foo`是类方法，因此`class_foo`与类`Kls`进行了绑定（而不是与实例`ik`绑定）。当我们打印`ik.class_foo`时，输出结果为：

<bound method type.class_foo of <class '__main__.Kls'>>

当调用`ik.static_foo`时，静态方法不会与类或实例进行绑定。因此，打印`ik.static_foo`（或`Kls.static_foo`）时输出结果为：

<function static_foo at 0x055238B0>

综上所述，实例方法、类方法和静态方法的核心区别在于它们是否与类或实例对象进行绑定。

至此，关于Python实例方法、类方法和静态方法的介绍与区别分析已完成。如需了解更多Python实例方法相关内容，请搜索本站历史文章或继续浏览后续相关文章。感谢大家的支持！