Python 面向对象之绑定和非绑定方法

发布时间:2024年01月03日

Python 面向对象之绑定和非绑定方法

【一】序言

  • 在Python成员中分为两类:一个是属性,另一个就是方法(就是定义的函数)
  • 方法又分为两大类:绑定方法(动态方法)非绑定方法(静态方法)
  • 从名字上就能知道他们的区别,一个绑定了另一个没有绑定,那么接下来就将具体的讲讲

【二】绑定方法

  • 绑定方法就是指与特定对象关联的方法
  • 它也被分为两大类:绑定给对象的实例方法(对象方法)和绑定给类的类方法

【1】实例方法(对象方法)

(1)概念
  • 绑定到对象上的方法,基本都是为对象服务

  • 没有被任何装饰器装饰的方法

  • 第一个参数时self,实例本身

  • 对象调用实例方法时(对象.实例方法()),自动将对象当作第一个参数传入

  • 类调用实例方法时(类.实例方法(类())),需要手动传入一个实例

  • 一个类的实例方法绑定到不同的对象就是不同的实例方法内存地址各不相同

(2)代码解释
# 绑定给对象,为对象服务
# 没有任何装饰器
class Plant:
    plant_owner = "戴夫"
	
    # 没有装饰器
    # 这个也是实例方法
    def __init__(self, name, health, attack_value):
        self.name = name
        self.health = health
        self.attack_value = attack_value

    # 没有装饰器
    def introduce(self):
        print(f"""
        我是{self.name}
        我的生命值为{self.health},
        我的攻击力为{self.attack_value},
        我的主人是{self.plant_owner}
        """)
# 实例对象
pee_shooter = Plant(name="豌豆射手", health=80, attack_value=10)
# 为对象服务
pee_shooter.introduce()
#         我是豌豆射手
#         我的生命值为80,
#         我的攻击力为10,
#         我的主人是戴夫
# 当对象调用实例方法时,自动将对象当作第一个参数传入
# 当类调用实例方法时,需要手动传入一个实例

# 实例化对象
pee_shooter = Plant(name="豌豆射手", health=80, attack_value=10)
# 对象调用实例方法
pee_shooter.introduce_self()
# 实例方法self的内容为:<__main__.Plant object at 0x000001DBD811B970>

# 类调用实例方法,需要手动传入一个实例
Plant.introduce_self(pee_shooter)
# 一个类的实例方法绑定到不同的实例对象,他们就是不同的实例方法,因为他们地址不同

# 实例化对象
sunflower = Plant(name="向日葵", health=100, attack_value=0)
pee_shooter = Plant(name="豌豆射手", health=80, attack_value=10)

# 获取类的实例方法的地址
print(id(Plant.introduce))
# 查看绑定到不同对象的实例方法的地址
print(id(sunflower.introduce))
print(id(pee_shooter.introduce))
# 1847514406128             # 地址都不一样
# 1847514372160
# 1847514372096

【2】类方法

(1)概念
  • 绑定到类上的方法,基本都是为类服务

  • classmethod装饰器装饰的方法

  • 第一个参数时cls,类本身

  • 类调用类方法时(类.实例方法()),自动将类当作第一个参数传入

  • 对象调用实例方法时(对象.实例方法()),自动将对象的类当作第一个参数传入

(2)代码解释
# 绑定到类上,为类服务
# 用classmethod装饰器装饰
# 第一个参数是cls

class Plant:
    plant_owner = "戴夫"
    plant_rival = "僵尸博士"

    def __init__(self, name, health, attack_value):
        self.name = name
        self.health = health
        self.attack_value = attack_value

    # 用classmethod装饰器装饰
	# 第一个参数是cls
    @classmethod
    def introduce_rival(cls):
        print(f"{cls.__name__}的对手是{cls.__dict__['plant_rival']}")

# 为类服务
Plant.introduce_rival()
# 无论是类还是实例调用实例方法,都会自动传入类给cls参数
# 一个类的实例方法绑定到不同的实例对象,他们就是不同的实例方法,因为他们地址不同
class Plant:
    plant_owner = "戴夫"
    plant_rival = "僵尸博士"

    def __init__(self, name, health, attack_value):
        self.name = name
        self.health = health
        self.attack_value = attack_value

    @classmethod
    def introduce_rival(cls):
        print(f"{cls.__name__}的对手是{cls.__dict__['plant_rival']}")

# 类调用类方法
print(id(Plant.introduce_rival))
Plant.introduce_rival()
# 1693174119296
# Plant的对手是僵尸博士

# 实例化对象
pee_shooter = Plant("豌豆射手", 80,10)
# 实例对象调用类方法
print(id(pee_shooter.introduce_rival))
pee_shooter.introduce_rival()
# 1693174119296                 
# Plant的对手是僵尸博士
  • 可以看到地址相同,即是同一个内容

【三】非绑定方法

  • 非绑定方法就是既没有绑定给类也没有绑定给对象的方法,谁也没有绑定
【1】非绑定方法
(1)概念
  • 不和类也不和对象进行绑定

  • staticmethod装饰器装饰的方法

  • 就是一个普普通通方法(函数),没有特殊的参数

  • 可以在类的外部直接调用(类.非绑定方法())(对象.非绑定方法())

(2)代码解释
class Plant:
    plant_owner = "戴夫"
    plant_rival = "僵尸博士"

    def __init__(self, name, health, attack_value):
        self.name = name
        self.health = health
        self.attack_value = attack_value

    @staticmethod
    def static_method():
        print("这是植物类的静态方法")

# 实例化对象
pee_shooter = Plant(name="豌豆射手", health=80, attack_value=10)

# 实例访问
print(id(pee_shooter.static_method))
pee_shooter.static_method()
# 2055404428960
# 这是植物类的静态方法

# 类访问
print(id(Plant.static_method))
Plant.static_method()
# 2055404428960             # 地址相同
# 这是植物类的静态方法
  • 可以看到地址相同,即是同一个内容

【四】总结

请添加图片描述

文章来源:https://blog.csdn.net/weixin_48183870/article/details/135368022
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。