从空间的角度研究类

一, 类的空间问题

1. 何处可以添加对象属性

   class A:
       def __init__(self, name):
           self.name = name
   
       def func(self, sex):
           self.sex = sex
   
   # 类外面可以
   obj = A('太上老君')
   obj.age = 18
   print(obj.__dict__)  # {'name': '太上老君', 'age': 18}
   
   # 类内部也可以
   obj = A('元始天尊') # __init__方法可以
   obj.func('男')      # func 方法也可以
   print(obj.__dict__) # {'name': '元始天尊', 'sex': '男'}
   
   # 总结: 对象的属性不仅可以在__init__里面添加,还可以在类的其他地方或者类的外面添加
   

2. 何处可以添加类的静态属性

   class A:
       def __init__(self, name):
           self.name = name
       def func(self, sex):
           self.sex = sex
   
       def func1(self):
           A.bbb = 'ccc'
   
   # 类的外部可以添加
   A.aaa = 'dsb'
   print(A.__dict__)
   
   # 类的内部也可以添加
   A.func1(111)
   print(A.__dict__)
   
   # 总结: 类的属性不仅可以在类内部添加,还可以在类的外部添加
   

3. 对象和类查找属性的顺序:

   • 对象之所以可以找到类,是因为对象空间中有类对象指针这么个东西

   • 对象查找属性的顺序:

     对象空间>类空间>父类空间==>...

   • 类名查找属性的顺序:

     本类空间>父类空间>...

   • 查找顺序是单项不可逆的,类名不可能找到对象的属性

二, 类与类之间的关系

1. 依赖关系:

   • 将一个类的对象或者类名传到另一个类的方法使用,这两个类之间就是依赖关系

   # 大象进冰箱
   class Elephant:
       def __init__(self, name):
           self.name = name
   
       def open_(self, self2):
           print(f'{self.name}大象打开冰箱门')
           self2.open_door() # 依赖关系还是通过原对象.的方式调用方法
   
       def close_(self, self2):
           print(f'{self.name}大象关上冰箱门')
           self2.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}冰箱门被关上了')
   
   daxiang = Elephant('奇奇')
   bingxiang = Refrigerator('格力')
   daxiang.open_(bingxiang)
   daxiang.close_(bingxiang)
   # 奇奇大象打开冰箱门
   # 格力冰箱门被打开了
   # 奇奇大象关上冰箱门
   # 格力冰箱门被关上了
   

2. 关联,聚合,组合关系(在python中统一叫组合关系)

   • 组合关系:将一个类的对象封装到另一个类的对象的属性中,就叫组合

   # 男孩的女朋友
   class Boy:
       def __init__(self, name, girlfriend=None):
           self.name = name
           self.girlfriend = girlfriend  # 将另一个对象作为属性,封装到本对象中
       def have_a_diner(self):
           if self.girlfriend:
               print(f'{self.name}和{self.girlfriend.name}一起吃晚饭.')
               self.girlfriend.shopping(self) # 组合关系是以当前对象为主体调用另一个对象的方法
           else:
               print('单身狗,吃什么饭.')
   
   class Girl:
       def __init__(self, name):
           self.name = name
       def shopping(self, self2):
           print(f'{self.name}和{self2.name}一起去购物')
   b = Boy('小明')
   b.have_a_diner() # 此时单身狗
   
   g = Girl('小丽')
   b.girlfriend = g # 有了女朋友
   b.have_a_diner()
   
   gg = Girl('小花')
   bb = Boy('小李', gg)
   bb.have_a_diner()
   
   bb.girlfriend = None  # 分手了
   bb.have_a_diner()
   

   # 学校和老师
   class School:
       def __init__(self, name, address):
           self.name = name
           self.address = address
   
   class Teacher:
       def __init__(self, name, school):
           self.name = name
           self.school = school
   
   s1 = School('北京大学', '喧哗的北京')
   s2 = School('浙江大学', '美丽的浙江')
   s3 = School('武汉大学', '美女如云的武汉')
   
   t1 = Teacher('王健林', s1)
   t2 = Teacher('马云', s2)
   t3 = Teacher('董明珠', s3)
   
   print(t1.school.name)
   print(t2.school.name)
   print(t3.school.name)
   

   # 设计一个游戏人物类,实例化几个对象让这几个游戏人物实现互殴的效果
   class Gamerole:
       def __init__(self, name, ad, hp):
           self.name = name
           self.ad = ad
           self.hp = hp
       def attack(self, p1):
           p1.hp -= self.ad
           print(f'{self.name}攻击了{p1.name},{p1.name}掉了{self.ad}血,还剩{p1.hp}血')
   
   # 再写个武器类
   class Weapon:
       def __init__(self, name, ad):
           self.name = name
           self.ad = ad
       def weapon_attack(self, p1, p2):
           p2.hp = p2.hp - p1.ad - self.ad
           print(f'{p1.name}利用{self.name}攻击了{p2.name},{p2.name}还剩{p2.hp}血')
           
   gailun = Gamerole('德玛西亚之力', 10, 200)
   yasuo = Gamerole('疾风剑豪', 20, 80)
   dabaojian = Weapon('大宝剑', 20)
   dabaojian.weapon_attack(gailun, yasuo)
   
   # 但是这样不好,利用武器攻击也是人类是动作的发起者,所以不能是dabaojian对象发起
   ------------------修改后如下------------------
   # 修改代码
   class Gamerole:
       def __init__(self, name, ad, hp):
           self.name = name
           self.ad = ad
           self.hp = hp
       def attack(self, p1):
           p1.hp -= self.ad
           print(f'{self.name}攻击了{p1.name},{p1.name}掉了{self.ad}血,还剩{p1.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 - p1.ad - self.ad
           print(f'{p1.name}利用{self.name}攻击了{p2.name},{p2.name}还剩{p2.hp}血')
   
   # 实例化2个人物,1个武器
   gailun = Gamerole('德玛西亚之力', 10, 200)
   yasuo = Gamerole('疾风剑豪', 20, 80)
   dabaojian = Weapon('大宝剑', 20)
   
   # 给人物装备上武器对象
   gailun.equip_weapon(dabaojian)
   
   # 开始攻击
   gailun.wea.weapon_attack(gailun, yasuo) # 攻击是以盖伦为主体的