python之面向对象类空间问题以及类之间的关系

1. 类的空间问题

   • 对象的属性不仅可以在__init__中添加，还可以在类的其他方法和类的外面添加

     class Human:
         def __init__(self,name):
             self.name = name
     
         def func(self,sex):
             self.sex = sex
     # 类的外面：
     obj = Human('铁憨憨')
     obj.age = 18
     print(obj.__dict__)	# {'name': '铁憨憨', 'age': 18}
     # 类的其他方法中：
     obj = Human('铁憨憨')
     obj.func('男')	# {'name': '铁憨憨', 'age': 18，'sex':'男'}
     

   • 类的属性不仅可以在类内部添加，还可以在类的外部添加

     class Human:
         def __init__(self,name):
             self.name = name
     
         def func(self,sex):
             self.sex = sex
         
         def func1(self):
             Human.bbb = '皮皮寒'
     # 类的外部：
     Human.aaa = '铁憨憨'
     # 类的内部：
     Human.func1(123)
     

   • 对象中之所以可以找到类中的属性，是因为在实例化的过程中对象空间中会产生一个类对象指针。

     • 当对象查找属性时：先从对象空间找----->类空间找----->父类空间找------>....
     • 当类名查找属性时：先从本类空间找----->父类空间找----->....

2. 类与类之间的关系

   • 依赖关系：将一个类的对象或者类名传到另一个类的方法中去使用时，我们就说这两个类时依赖关系。

     class Elphant:
         def __init__(self,name):
             self.name = name
     
         def open(self,ref):
             print(f'{self.name}默念三声:芝麻开门')
             ref.open_door()
         def close(self,ref):
             print(f'{self.name}默念三声:芝麻关门')
             ref.close_door()
     
     class Refrigerator:
     
         def __init__(self,name):
             self.name = name
         def open_door(self):
             print(f'{self.name}冰箱门被打开了')
     
         def close_door(self):
             print(f'{self.name}冰箱门被关上了')
     
     ele = Elphant('大象')
     ref = Refrigerator('海尔')
     ele.open(ref)
     ele.close(ref)
     # 大象默念三声:芝麻开门
     # 海尔冰箱门被打开了
     # 大象默念三声:芝麻关门
     # 海尔冰箱门被关上了
     

   • 组合关系：将一个类的对象封装到另一个类的对象的属性中

     class Boy:
         def __init__(self,name):
             self.name = name
         def meet(self,girl_friend = None):
             self.girl_friend = girl_friend	# 给对象添加新属性girl_friend，此时girl_friend为对象flower
         def have_diner(self):
             if self.girl_friend:
                 print(f'{self.name}请{self.girl_friend.name}一起吃六块钱的麻辣烫')
                 self.girl_friend.shopping(self)	# self其实就是wu对象
             else:
                 print('单身狗,吃什么吃')
     class Girl:
         def __init__(self,name,age):
             self.name = name
             self.age = age
         def shopping(self,obj):
             self.obj = obj	# 给flower对象添加新属性obj，此时obj为对象wu
             print(f'{self.obj.name}和{self.name}一起去购物!')
     
     wu = Boy('吴超')
     flower = Girl("如花",48)
     wu.meet(flower)	#将flower传给girl_friend
     wu.have_diner()
     # 吴超请如花一起吃六块钱的麻辣烫
     # 吴超和如花一起去购物!
     

     模拟游戏人物攻击：

     class Gamerole:
         def __init__(self,name,ad,hp):
             self.name = name
             self.ad = ad
             self.hp = hp        
         def equip_weapon(self,wea):
             self.wea = wea  # 组合：给一个对象封装一个属性此属性是另一个类的对象
     class Weapon:
         def __init__(self,name,ad):
             self.name = name
             self.ad = ad
         def weapon_attack(self,p1,p2):
             p2.hp = p2.hp - self.ad - p1.ad
             print(f'{p1.name}利用{self.name}攻击了{p2.name},{p2.name}还剩{p2.hp血}')
     
     # 实例化三个人物对象：
     barry = Gamerole('铁憨憨',10,200)
     panky = Gamerole('碎梦',20,50)
     pillow = Weapon('铁拳套',2)
     
     # 给人物装备武器对象。
     barry.equip_weapon(pillow)
     
     # 开始攻击
     barry.wea.weapon_attack(barry,panky)
     
     

     上面就是组合，只要人物.equip_weapon这个方法，那么人物就封装了一个武器对象，再利用武器对象调用其类中的weapon_attack方法。