Python-实例方法、类方法和静态方法

分类 Python 标签 Python 评论:
  1. 实例方法、类方法和静态方法
    1. 实例方法
      1. 给实例对象和类对象动态的绑定实例方法
    2. 类方法
    3. 静态方法

实例方法、类方法和静态方法

实例方法

只有实例对象才可以调用的方法，有两种调用方式：

1、在类对象的内部（其他实例方法中）
语法格式：self.方法名([实参])
2、在类对象的外部
语法格式：实例对象.方法名([实参])
类对象的所有实例对象都有一个指向类对象的指针，所以，类对象的所有实例对象都可以调用类对象中定义的实例方法。

#!/usr/bin/python3


class MyClass(object):

    # 在类对象中定义实例方法
    def im1(self, p1, p2):
        print(p1, p2)
    
    
    def im2(self):
        # 在类对象的内部（其他实例方法中）调用实例方法
        self.im1(3, 4)

mc = MyClass()

# 在类对象外部调用实例方法
mc.im1(1, 2)
mc.im2()

[root@lyucan ~]# ./7.py
1 2
3 4

给实例对象和类对象动态的绑定实例方法

python是动态语言，在是对象或类对象创建之后，可以对其动态的绑定实例方法。
同一个类对象的不同实例对象所动态绑定的实例方法是相互独立的。也就是说，给一个实例对象动态绑定的实例方法，对于另一个实例对象是不起作用的。

#!/usr/bin/python3


class MyClass(object):
    def im1(self, p1, p2):
        print(p1, p2)

    def im2(self):
        self.im1(3, 4)

mc = MyClass()


#mc.im1(1, 2)

#mc.im2()


#############################

# 定义一个函数作为实例方法
def do_sth(self):
    print('do_sth被调用了')

from types import MethodType

# 给实例对象动态的绑定实例方法
mc.do_sth = MethodType(do_sth, mc)

# 调用绑定的实例方法
mc.do_sth()

# 定义一个新的实例对象，分别调用事先定义实例方法和动态绑定的实例方法，动态绑定的方法是不可用的
mc2 = MyClass()
mc2.im1(1, 2)
mc2.do_sth()

[root@lyucan ~]# ./7.py
do_sth被调用了
1 2
Traceback (most recent call last):
  File "./7.py", line 31, in <module>
    mc2.do_sth()
AttributeError: 'MyClass' object has no attribute 'do_sth'

为了能让一个类对象的所有实例对象都可以调用某个动态绑定的实例方法，可以给类对象绑定该实例方法

#!/usr/bin/python3


class MyClass(object):
    def im1(self, p1, p2):
        print(p1, p2)

    def im2(self):
        self.im1(3, 4)


# 定义一个函数作为实例方法
def do_sth2(self):
    print('do_sth2 被调用了')

# 给类对象动态绑定该实例方法
MyClass.do_sth2 = do_sth2

im1 = MyClass()

im2 = MyClass()

im1.do_sth2()
im2.do_sth2()

[root@lyucan ~]# ./8.py
do_sth2 被调用了
do_sth2 被调用了

类方法

指的是类对象中使用装饰器@classmethod进行装饰的方法
在类对象中定义类方法时，必须使用装饰器@classmethod进行装饰，此外，第一个形参表示类对象，其对应的实参由系统自动传入，第一个形参的名称通常是cls，也可以是其他名字。

类方法可以被类对象所调用，语法格式：类对象.方法名([实参])，或者：cls.方法名([实参])。
类方法也可以被实例对象所调用，语法格式：实例对象.方法名([实参])，或者：self.方法名([实参])。

类对象的所有实例对象都有一个指向类对象的指针，所以，类对象的所有实例对象都可以调用类对象中定义的类方法。

调用类方法是，系统自动将类对象作为实参传递给第一个形参，第一个实参会传递给第二个形参，第二个实参会传递给第三个形参，依次类推。

#!/usr/bin/python3

class MyClass(object):
    @classmethod
    def cm1(cls, p1, p2):
        print(p1, p2)

    @classmethod
    def cm2(cls):
        MyClass.cm1(1, 2)
        cls.cm1(3, 4)

    def im1(self):
        # 在实例方法中调用类方法
        self.cm2()

mc = MyClass()

# 使用类对象调用类方法
print('使用类对象调用类方法')
MyClass.cm1(1, 2)
MyClass.cm2()
print('')
# 使用实例对象调用类方法
print('使用实例对象调用类方法')
mc.cm1(5, 6)
mc.cm2()
mc.im1()

[root@lyucan ~]# ./8.py
使用类对象调用类方法
1 2
1 2
3 4

使用实例对象调用类方法
5 6
1 2
3 4
1 2
3 4

静态方法

类对象的静态方法只是一个普通函数，把某个普通函数归属于某个类对象，可能只是为了易于管理。

在类对象中定义静态方法时，必须使用装饰器@staticmethod进行装饰，静态方法只是一个普通函数，因此，第一个形参没有普通含义和要求。

静态方法可以被类对象所调用，语法格式为：类对象.方法名([实参])，或者：cls.方法名([实参])
静态方法也可以被实例对象所调用，语法格式为：实例对象.方法名([实参])，或者：self.方法名([实参])

类对象的所有实例对象都有一个指向类对象的指针，所以，类对象的所有实例对象都可以调用类对象中定义的静态方法。

调用静态方式时的函数与调用普通函数是一样的

#!/usr/bin/python3

class MyClass(object):
    @staticmethod
    def sm(p1, p2):
        print(p1, p2)

    @classmethod
    def cm(cls):
        # 在类方法中调用静态方法
        MyClass.sm(1, 2)
        cls.sm(3, 4)

    def im(self):
        # 在实例方法中调用静态方法
        self.sm(5, 6)


mc = MyClass()
# 使用实例调用静态方法
mc.sm(11, 22)

mc.cm()
mc.im()

[root@lyucan ~]# vim 9.py
[root@lyucan ~]# ./9.py
11 22
1 2
3 4
5 6

27963bdd-aed0-4fbd-9472-20dcee6bd5f0-image.png

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 289211569@qq.com

©2016-2023 Daryl