1.图示

　　　　

2 程序

　　1）版本1：框架的搭建

  1. def main():
  2.     '''用来控制这个程序的流程'''
  3.     pass
  4.  
  5.     #1.创建alex对象
  6.  
  7.     #2.创建1个枪对象
  8.  
  9.     #3.创建1个弹夹对象
  10.  
  11.     #4.创建子弹对象
  12.  
  13.     #5.创建一个敌人
  14.  
  15.     #6.alex把子弹安装到弹夹中
  16.  
  17.     #7.alex把弹夹安装到枪中
  18.  
  19.     #8.alex拿枪
  20.  
  21.     #9.alex拿枪打jack
  22.  
  23. if __name__ == "__main__":
  24.     main()

　　2）版本2：创建类对象

  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.  
  6. class Gun(object):
  7.     '''一个枪的类'''
  8.     def __init__(self,name):
  9.         self.name = name   #用来记录枪的类型
  10.  
  11. class Gun_jia(object):
  12.     '''弹夹的类'''
  13.     def __init__(self,max_num):
  14.         self.max = max_num   #用来记录弹夹的最大容量
  15.  
  16. class Gun_dan(object):
  17.     '''子弹类'''
  18.     def __init__(self,damage):
  19.         self.damage = damage  #记录子弹的伤害
  20.  
  21. def main():
  22.     '''用来控制这个程序的流程'''
  23.     pass
  24.  
  25.     #1.创建alex对象
  26.     alex = Person("alex")
  27.  
  28.     #2.创建1个枪对象
  29.     ak47 = Gun("AK47")
  30.  
  31.     #3.创建1个弹夹对象
  32.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  33.  
  34.     #4.创建子弹对象
  35.     gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  36.  
  37.     #6.alex把子弹安装到弹夹中
  38.  
  39.     #7.alex把弹夹安装到枪中
  40.  
  41.     #8.alex拿枪
  42.  
  43.     #5.创建一个敌人
  44.  
  45.     #9.alex拿枪打jack
  46.  
  47. if __name__ == "__main__":
  48.     main()

　　

　　3）版本3：安装子弹

  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.  
  6.     def install(self,gun_jia_temp,gun_dan_temp):
  7.         '''把子弹安装到弹夹'''
  8.         #弹夹.保存子弹(子弹)
  9.         gun_jia_temp.save(gun_dan_temp)
  10.  
  11. class Gun(object):
  12.     '''一个枪的类'''
  13.     def __init__(self,name):
  14.         self.name = name   #用来记录枪的类型
  15.  
  16. class Gun_jia(object):
  17.     '''弹夹的类'''
  18.     def __init__(self,max_num):
  19.         self.max = max_num   #用来记录弹夹的最大容量
  20.         self.list_dan = []  #用来记录所有子弹的引用
  21.  
  22.     def save(self,gun_dan_temp):
  23.         '''把子弹保存到弹夹'''
  24.         self.list_dan.append(gun_dan_temp)
  25.  
  26. class Gun_dan(object):
  27.     '''子弹类'''
  28.     def __init__(self,damage):
  29.         self.damage = damage  #记录子弹的伤害
  30.  
  31. def main():
  32.     '''用来控制这个程序的流程'''
  33.     pass
  34.  
  35.     #1.创建alex对象
  36.     alex = Person("alex")
  37.  
  38.     #2.创建1个枪对象
  39.     ak47 = Gun("AK47")
  40.  
  41.     #3.创建1个弹夹对象
  42.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  43.  
  44.     #4.创建子弹对象
  45.     gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  46.  
  47.     #6.alex把子弹安装到弹夹中
  48.     #alex.安装子弹到弹夹中（弹夹，子弹）
  49.     alex.install(gun_jia,gun_dan)
  50.  
  51.     #7.alex把弹夹安装到枪中
  52.  
  53.     #8.alex拿枪
  54.  
  55.     #5.创建一个敌人
  56.  
  57.     #9.alex拿枪打jack
  58.  
  59. if __name__ == "__main__":
  60.     main()

　　

　　4）安装弹夹

  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.  
  6.     def install(self,gun_jia_temp,gun_dan_temp):
  7.         '''把子弹安装到弹夹'''
  8.         #弹夹.保存子弹(子弹)
  9.         gun_jia_temp.save(gun_dan_temp)
  10.  
  11.     def install2(self,gun_temp,gun_jia_temp):
  12.         '''安装弹夹到枪'''
  13.         #枪保存弹夹
  14.         gun_temp.save2(gun_jia_temp)
  15.  
  16. class Gun(object):
  17.     '''一个枪的类'''
  18.     def __init__(self,name):
  19.         self.name = name   #用来记录枪的类型
  20.         self.gun_jia = None  #用来记录弹夹对象的引用
  21.  
  22.     def save2(self,gun_jia_temp):
  23.         '''用一个属性来保存这个弹夹对象的引用'''
  24.         self.gun_jia = gun_jia_temp
  25.  
  26. class Gun_jia(object):
  27.     '''弹夹的类'''
  28.     def __init__(self,max_num):
  29.         self.max = max_num   #用来记录弹夹的最大容量
  30.         self.list_dan = []  #用来记录所有子弹的引用
  31.  
  32.     def save(self,gun_dan_temp):
  33.         '''把子弹保存到弹夹'''
  34.         self.list_dan.append(gun_dan_temp)
  35.  
  36. class Gun_dan(object):
  37.     '''子弹类'''
  38.     def __init__(self,damage):
  39.         self.damage = damage  #记录子弹的伤害
  40.  
  41. def main():
  42.     '''用来控制这个程序的流程'''
  43.     pass
  44.  
  45.     #1.创建alex对象
  46.     alex = Person("alex")
  47.  
  48.     #2.创建1个枪对象
  49.     ak47 = Gun("AK47")
  50.  
  51.     #3.创建1个弹夹对象
  52.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  53.  
  54.     #4.创建子弹对象
  55.     gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  56.  
  57.     #6.alex把子弹安装到弹夹中
  58.     #alex.安装子弹到弹夹中（弹夹，子弹）
  59.     alex.install(gun_jia,gun_dan)
  60.  
  61.     #7.alex把弹夹安装到枪中
  62.     #alex.安装弹夹到枪(枪，弹夹)
  63.     alex.install2(ak47,gun_jia)
  64.  
  65.     #8.alex拿枪
  66.  
  67.     #5.创建一个敌人
  68.  
  69.     #9.alex拿枪打jack
  70.  
  71. if __name__ == "__main__":
  72.     main()

　　5）测试弹夹，枪

  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.  
  6.     def install(self,gun_jia_temp,gun_dan_temp):
  7.         '''把子弹安装到弹夹'''
  8.         #弹夹.保存子弹(子弹)
  9.         gun_jia_temp.save(gun_dan_temp)
  10.  
  11.     def install2(self,gun_temp,gun_jia_temp):
  12.         '''安装弹夹到枪'''
  13.         #枪保存弹夹
  14.         gun_temp.save2(gun_jia_temp)
  15.  
  16. class Gun(object):
  17.     '''一个枪的类'''
  18.     def __init__(self,name):
  19.         self.name = name   #用来记录枪的类型
  20.         self.gun_jia = None  #用来记录弹夹对象的引用
  21.  
  22.     def save2(self,gun_jia_temp):
  23.         '''用一个属性来保存这个弹夹对象的引用'''
  24.         self.gun_jia = gun_jia_temp
  25.  
  26.     def __str__(self):
  27.         if self.gun_jia:
  28.             return "枪的信息为:%s,弹夹的信息为:%s"%(self.name,self.gun_jia)
  29.         else:
  30.             return "枪的信息为:%s,没有弹夹..."%(self.name)
  31.  
  32. class Gun_jia(object):
  33.     '''弹夹的类'''
  34.     def __init__(self,max_num):
  35.         self.max = max_num   #用来记录弹夹的最大容量
  36.         self.list_dan = []  #用来记录所有子弹的引用
  37.  
  38.     def save(self,gun_dan_temp):
  39.         '''把子弹保存到弹夹'''
  40.         self.list_dan.append(gun_dan_temp)
  41.  
  42.     def __str__(self):
  43.         return "弹夹的信息为:%d/%d"%(len(self.list_dan),self.max)
  44.  
  45. class Gun_dan(object):
  46.     '''子弹类'''
  47.     def __init__(self,damage):
  48.         self.damage = damage  #记录子弹的伤害
  49.  
  50. def main():
  51.     '''用来控制这个程序的流程'''
  52.     pass
  53.  
  54.     #1.创建alex对象
  55.     alex = Person("alex")
  56.  
  57.     #2.创建1个枪对象
  58.     ak47 = Gun("AK47")
  59.  
  60.     #3.创建1个弹夹对象
  61.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  62.  
  63.     #4.创建子弹对象
  64.     for i in range(15):
  65.         gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  66.  
  67.         #6.alex把子弹安装到弹夹中
  68.         #alex.安装子弹到弹夹中（弹夹，子弹）
  69.         alex.install(gun_jia,gun_dan)
  70.  
  71.     #7.alex把弹夹安装到枪中
  72.     #alex.安装弹夹到枪(枪，弹夹)
  73.     alex.install2(ak47,gun_jia)
  74.  
  75.     #test1:测试弹夹的信息
  76.     print(gun_jia)
  77.  
  78.     #test2:测试枪的信息
  79.     print(ak47)
  80.  
  81.     #8.alex拿枪
  82.  
  83.     #5.创建一个敌人
  84.  
  85.     #9.alex拿枪打jack
  86.  
  87. if __name__ == "__main__":
  88.     main()
  1. 弹夹的信息为:15/20
  2. 枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20

　　

　　6）老王拿枪，并且测试

  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.         self.gun = None  #用来保存枪对象的引用
  6.         self.hp = 100
  7.  
  8.     def install(self,gun_jia_temp,gun_dan_temp):
  9.         '''把子弹安装到弹夹'''
  10.         #弹夹.保存子弹(子弹)
  11.         gun_jia_temp.save(gun_dan_temp)
  12.  
  13.     def install2(self,gun_temp,gun_jia_temp):
  14.         '''安装弹夹到枪'''
  15.         #枪保存弹夹
  16.         gun_temp.save2(gun_jia_temp)
  17.  
  18.     def catch(self,gun_temp):
  19.         '''拿枪'''
  20.         self.gun = gun_temp
  21.  
  22.     def __str__(self):
  23.         if self.gun:
  24.             return "%s的血量是:%d,他有枪,%s"%(self.name,self.hp,self.gun)
  25.         else:
  26.             return "%s的血量是%d,他没有枪.."%(self.name,self.hp)
  27.  
  28. class Gun(object):
  29.     '''一个枪的类'''
  30.     def __init__(self,name):
  31.         self.name = name   #用来记录枪的类型
  32.         self.gun_jia = None  #用来记录弹夹对象的引用
  33.  
  34.     def save2(self,gun_jia_temp):
  35.         '''用一个属性来保存这个弹夹对象的引用'''
  36.         self.gun_jia = gun_jia_temp
  37.  
  38.     def __str__(self):
  39.         if self.gun_jia:
  40.             return "枪的信息为:%s,弹夹的信息为:%s"%(self.name,self.gun_jia)
  41.         else:
  42.             return "枪的信息为:%s,没有弹夹..."%(self.name)
  43.  
  44. class Gun_jia(object):
  45.     '''弹夹的类'''
  46.     def __init__(self,max_num):
  47.         self.max = max_num   #用来记录弹夹的最大容量
  48.         self.list_dan = []  #用来记录所有子弹的引用
  49.  
  50.     def save(self,gun_dan_temp):
  51.         '''把子弹保存到弹夹'''
  52.         self.list_dan.append(gun_dan_temp)
  53.  
  54.     def __str__(self):
  55.         return "弹夹的信息为:%d/%d"%(len(self.list_dan),self.max)
  56.  
  57. class Gun_dan(object):
  58.     '''子弹类'''
  59.     def __init__(self,damage):
  60.         self.damage = damage  #记录子弹的伤害
  61.  
  62. def main():
  63.     '''用来控制这个程序的流程'''
  64.     pass
  65.  
  66.     #1.创建alex对象
  67.     alex = Person("alex")
  68.  
  69.     #2.创建1个枪对象
  70.     ak47 = Gun("AK47")
  71.  
  72.     #3.创建1个弹夹对象
  73.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  74.  
  75.     #4.创建子弹对象
  76.     for i in range(15):
  77.         gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  78.  
  79.         #6.alex把子弹安装到弹夹中
  80.         #alex.安装子弹到弹夹中（弹夹，子弹）
  81.         alex.install(gun_jia,gun_dan)
  82.  
  83.     #7.alex把弹夹安装到枪中
  84.     #alex.安装弹夹到枪(枪，弹夹)
  85.     alex.install2(ak47,gun_jia)
  86.  
  87.     #test1:测试弹夹的信息
  88.     print(gun_jia)
  89.  
  90.     #test2:测试枪的信息
  91.     print(ak47)
  92.  
  93.     #8.alex拿枪
  94.     #alex.拿枪（枪）
  95.     alex.catch(ak47)
  96.  
  97.     #test3.测试老王对象
  98.     print(alex)
  99.  
  100.     #5.创建一个敌人
  101.  
  102.     #9.alex拿枪打jack
  103.  
  104. if __name__ == "__main__":
  105.     main()
  1. 弹夹的信息为:15/20
  2. 枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20
  3. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20

　　7）创建敌人

  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.         self.gun = None  #用来保存枪对象的引用
  6.         self.hp = 100
  7.  
  8.     def install(self,gun_jia_temp,gun_dan_temp):
  9.         '''把子弹安装到弹夹'''
  10.         #弹夹.保存子弹(子弹)
  11.         gun_jia_temp.save(gun_dan_temp)
  12.  
  13.     def install2(self,gun_temp,gun_jia_temp):
  14.         '''安装弹夹到枪'''
  15.         #枪保存弹夹
  16.         gun_temp.save2(gun_jia_temp)
  17.  
  18.     def catch(self,gun_temp):
  19.         '''拿枪'''
  20.         self.gun = gun_temp
  21.  
  22.     def __str__(self):
  23.         if self.gun:
  24.             return "%s的血量是:%d,他有枪,%s"%(self.name,self.hp,self.gun)
  25.         else:
  26.             return "%s的血量是%d,他没有枪.."%(self.name,self.hp)
  27.  
  28. class Gun(object):
  29.     '''一个枪的类'''
  30.     def __init__(self,name):
  31.         self.name = name   #用来记录枪的类型
  32.         self.gun_jia = None  #用来记录弹夹对象的引用
  33.  
  34.     def save2(self,gun_jia_temp):
  35.         '''用一个属性来保存这个弹夹对象的引用'''
  36.         self.gun_jia = gun_jia_temp
  37.  
  38.     def __str__(self):
  39.         if self.gun_jia:
  40.             return "枪的信息为:%s,弹夹的信息为:%s"%(self.name,self.gun_jia)
  41.         else:
  42.             return "枪的信息为:%s,没有弹夹..."%(self.name)
  43.  
  44. class Gun_jia(object):
  45.     '''弹夹的类'''
  46.     def __init__(self,max_num):
  47.         self.max = max_num   #用来记录弹夹的最大容量
  48.         self.list_dan = []  #用来记录所有子弹的引用
  49.  
  50.     def save(self,gun_dan_temp):
  51.         '''把子弹保存到弹夹'''
  52.         self.list_dan.append(gun_dan_temp)
  53.  
  54.     def __str__(self):
  55.         return "弹夹的信息为:%d/%d"%(len(self.list_dan),self.max)
  56.  
  57. class Gun_dan(object):
  58.     '''子弹类'''
  59.     def __init__(self,damage):
  60.         self.damage = damage  #记录子弹的伤害
  61.  
  62. def main():
  63.     '''用来控制这个程序的流程'''
  64.     pass
  65.  
  66.     #1.创建alex对象
  67.     alex = Person("alex")
  68.  
  69.     #2.创建1个枪对象
  70.     ak47 = Gun("AK47")
  71.  
  72.     #3.创建1个弹夹对象
  73.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  74.  
  75.     #4.创建子弹对象
  76.     for i in range(15):
  77.         gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  78.  
  79.         #6.alex把子弹安装到弹夹中
  80.         #alex.安装子弹到弹夹中（弹夹，子弹）
  81.         alex.install(gun_jia,gun_dan)
  82.  
  83.     #7.alex把弹夹安装到枪中
  84.     #alex.安装弹夹到枪(枪，弹夹)
  85.     alex.install2(ak47,gun_jia)
  86.  
  87.     #test1:测试弹夹的信息
  88.     print(gun_jia)
  89.  
  90.     #test2:测试枪的信息
  91.     print(ak47)
  92.  
  93.     #8.alex拿枪
  94.     #alex.拿枪（枪）
  95.     alex.catch(ak47)
  96.  
  97.     #test3.测试老王对象
  98.     print(alex)
  99.  
  100.     #5.创建一个敌人
  101.     jack = Person("jack")
  102.     print(jack)
  103.  
  104.     #9.alex拿枪打jack
  105.  
  106. if __name__ == "__main__":
  107.     main()
  1. 弹夹的信息为:15/20
  2. 枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20
  3. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20
  4. jack的血量是100,他没有枪..

　　

　　8）alex开枪？？？ 难点

  1.  #alex拿枪打jack
  2.  #老王.扣扳机（jack）
  3.  
  4. '''让枪发射子弹打敌人'''
  5. #枪.开火（敌人）
  6.  
  7. '''枪从弹夹中获取1发子弹，然后让子弹击中敌人'''
  8.  
  9. '''子弹打中人，让敌人掉血'''
  10.  
  11.  '''根据杀伤力，掉相应的血量'''
  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.         self.gun = None  #用来保存枪对象的引用
  6.         self.hp = 100
  7.  
  8.     def install(self,gun_jia_temp,gun_dan_temp):
  9.         '''把子弹安装到弹夹'''
  10.         #弹夹.保存子弹(子弹)
  11.         gun_jia_temp.save(gun_dan_temp)
  12.  
  13.     def install2(self,gun_temp,gun_jia_temp):
  14.         '''安装弹夹到枪'''
  15.         #枪保存弹夹
  16.         gun_temp.save2(gun_jia_temp)
  17.  
  18.     def catch(self,gun_temp):
  19.         '''拿枪'''
  20.         self.gun = gun_temp
  21.  
  22.     def __str__(self):
  23.         if self.gun:
  24.             return "%s的血量是:%d,他有枪,%s"%(self.name,self.hp,self.gun)
  25.         else:
  26.             return "%s的血量是%d,他没有枪.."%(self.name,self.hp)
  27.  
  28.     def pull(self,enemy):
  29.         '''让枪发射子弹打敌人'''
  30.         #枪.开火（敌人）
  31.         self.gun.fire(enemy)
  32.  
  33.     def lose_blood(self,damage):
  34.         '''根据杀伤力，掉相应的血量'''
  35.         self.hp -= damage
  36.  
  37. class Gun(object):
  38.     '''一个枪的类'''
  39.     def __init__(self,name):
  40.         self.name = name   #用来记录枪的类型
  41.         self.gun_jia = None  #用来记录弹夹对象的引用
  42.  
  43.     def save2(self,gun_jia_temp):
  44.         '''用一个属性来保存这个弹夹对象的引用'''
  45.         self.gun_jia = gun_jia_temp
  46.  
  47.     def __str__(self):
  48.         if self.gun_jia:
  49.             return "枪的信息为:%s,弹夹的信息为:%s"%(self.name,self.gun_jia)
  50.         else:
  51.             return "枪的信息为:%s,没有弹夹..."%(self.name)
  52.  
  53.     def fire(self,enemy):
  54.         '''枪从弹夹中获取1发子弹，然后让子弹击中敌人'''
  55.         #先从弹夹去子弹
  56.         #弹夹.弹出一发子弹
  57.         dan =  self.gun_jia.pop()
  58.  
  59.         #让这个子弹去伤害敌人
  60.         if dan:
  61.             #子弹.打中(敌人)
  62.             dan.hit(enemy)
  63.         else:
  64.             print("弹夹中没有子弹了")
  65.  
  66. class Gun_jia(object):
  67.     '''弹夹的类'''
  68.     def __init__(self,max_num):
  69.         self.max = max_num   #用来记录弹夹的最大容量
  70.         self.list_dan = []  #用来记录所有子弹的引用
  71.  
  72.     def save(self,gun_dan_temp):
  73.         '''把子弹保存到弹夹'''
  74.         self.list_dan.append(gun_dan_temp)
  75.  
  76.     def __str__(self):
  77.         return "弹夹的信息为:%d/%d"%(len(self.list_dan),self.max)
  78.  
  79.     def pop(self):
  80.         '''弹出最上面的1发子弹,给枪'''
  81.         if self.list_dan:
  82.             return self.list_dan.pop()
  83.         else:
  84.             return None
  85.  
  86. class Gun_dan(object):
  87.     '''子弹类'''
  88.     def __init__(self,damage):
  89.         self.damage = damage  #记录子弹的伤害
  90.  
  91.     def hit(self,enemy):
  92.         '''子弹打中人，让敌人掉血'''
  93.  
  94.         #敌人.掉血(一个子弹的伤害)
  95.         enemy.lose_blood(self.damage)
  96.  
  97. def main():
  98.     '''用来控制这个程序的流程'''
  99.     pass
  100.  
  101.     #1.创建alex对象
  102.     alex = Person("alex")
  103.  
  104.     #2.创建1个枪对象
  105.     ak47 = Gun("AK47")
  106.  
  107.     #3.创建1个弹夹对象
  108.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  109.  
  110.     #4.创建子弹对象
  111.     for i in range(15):
  112.         gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  113.  
  114.         #6.alex把子弹安装到弹夹中
  115.         #alex.安装子弹到弹夹中（弹夹，子弹）
  116.         alex.install(gun_jia,gun_dan)
  117.  
  118.     #7.alex把弹夹安装到枪中
  119.     #alex.安装弹夹到枪(枪，弹夹)
  120.     alex.install2(ak47,gun_jia)
  121.  
  122.     #test1:测试弹夹的信息
  123.     print(gun_jia)
  124.  
  125.     #test2:测试枪的信息
  126.     print(ak47)
  127.  
  128.     #8.alex拿枪
  129.     #alex.拿枪（枪）
  130.     alex.catch(ak47)
  131.  
  132.     #test3.测试老王对象
  133.     print(alex)
  134.  
  135.     #5.创建一个敌人
  136.     jack = Person("jack")
  137.     print(jack)
  138.  
  139.     #9.alex拿枪打jack
  140.     #老王.扣扳机（jack）
  141.     alex.pull(jack)
  142.     print(jack)
        print(alex)
  143.  
  144. if __name__ == "__main__":
  145.     main()
  1. 弹夹的信息为:15/20
  2. 枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20
  3. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:15/20
  4. jack的血量是100,他没有枪..
  5. jack的血量是90,他没有枪..
  6. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:14/20

　　10）没血了，就挂了

  1. ## 打了11枪了
  2.  
  3. jack的血量是-10,他没有枪..
  1. class Person(object):
  2.     '''人的类'''
  3.     def __init__(self,name):
  4.         self.name = name
  5.         self.gun = None  #用来保存枪对象的引用
  6.         self.hp = 100
  7.  
  8.     def install(self,gun_jia_temp,gun_dan_temp):
  9.         '''把子弹安装到弹夹'''
  10.         #弹夹.保存子弹(子弹)
  11.         gun_jia_temp.save(gun_dan_temp)
  12.  
  13.     def install2(self,gun_temp,gun_jia_temp):
  14.         '''安装弹夹到枪'''
  15.         #枪保存弹夹
  16.         gun_temp.save2(gun_jia_temp)
  17.  
  18.     def catch(self,gun_temp):
  19.         '''拿枪'''
  20.         self.gun = gun_temp
  21.  
  22.     def __str__(self):
  23.         if self.hp < 0:
  24.             return "%s他挂了..."%self.name
  25.         else:
  26.             if self.gun:
  27.                 return "%s的血量是:%d,他有枪,%s"%(self.name,self.hp,self.gun)
  28.             else:
  29.                 return "%s的血量是%d,他没有枪.."%(self.name,self.hp)
  30.  
  31.     def pull(self,enemy):
  32.         '''让枪发射子弹打敌人'''
  33.         #枪.开火（敌人）
  34.         self.gun.fire(enemy)
  35.  
  36.     def lose_blood(self,damage):
  37.         '''根据杀伤力，掉相应的血量'''
  38.         self.hp -= damage
  39.  
  40. class Gun(object):
  41.     '''一个枪的类'''
  42.     def __init__(self,name):
  43.         self.name = name   #用来记录枪的类型
  44.         self.gun_jia = None  #用来记录弹夹对象的引用
  45.  
  46.     def save2(self,gun_jia_temp):
  47.         '''用一个属性来保存这个弹夹对象的引用'''
  48.         self.gun_jia = gun_jia_temp
  49.  
  50.     def __str__(self):
  51.         if self.gun_jia:
  52.             return "枪的信息为:%s,弹夹的信息为:%s"%(self.name,self.gun_jia)
  53.         else:
  54.             return "枪的信息为:%s,没有弹夹..."%(self.name)
  55.  
  56.     def fire(self,enemy):
  57.         '''枪从弹夹中获取1发子弹，然后让子弹击中敌人'''
  58.         #先从弹夹去子弹
  59.         #弹夹.弹出一发子弹
  60.         dan =  self.gun_jia.pop()
  61.  
  62.         #让这个子弹去伤害敌人
  63.         if dan:
  64.             #子弹.打中(敌人)
  65.             dan.hit(enemy)
  66.         else:
  67.             print("弹夹中没有子弹了")
  68.  
  69. class Gun_jia(object):
  70.     '''弹夹的类'''
  71.     def __init__(self,max_num):
  72.         self.max = max_num   #用来记录弹夹的最大容量
  73.         self.list_dan = []  #用来记录所有子弹的引用
  74.  
  75.     def save(self,gun_dan_temp):
  76.         '''把子弹保存到弹夹'''
  77.         self.list_dan.append(gun_dan_temp)
  78.  
  79.     def __str__(self):
  80.         return "弹夹的信息为:%d/%d"%(len(self.list_dan),self.max)
  81.  
  82.     def pop(self):
  83.         '''弹出最上面的1发子弹,给枪'''
  84.         if self.list_dan:
  85.             return self.list_dan.pop()
  86.         else:
  87.             return None
  88.  
  89. class Gun_dan(object):
  90.     '''子弹类'''
  91.     def __init__(self,damage):
  92.         self.damage = damage  #记录子弹的伤害
  93.  
  94.     def hit(self,enemy):
  95.         '''子弹打中人，让敌人掉血'''
  96.  
  97.         #敌人.掉血(一个子弹的伤害)
  98.         enemy.lose_blood(self.damage)
  99.  
  100. def main():
  101.     '''用来控制这个程序的流程'''
  102.     pass
  103.  
  104.     #1.创建alex对象
  105.     alex = Person("alex")
  106.  
  107.     #2.创建1个枪对象
  108.     ak47 = Gun("AK47")
  109.  
  110.     #3.创建1个弹夹对象
  111.     gun_jia = Gun_jia(20)  #20代表弹夹的容量
  112.  
  113.     #4.创建子弹对象
  114.     for i in range(15):
  115.         gun_dan = Gun_dan(10)  #一个子弹掉10滴血
  116.  
  117.         #6.alex把子弹安装到弹夹中
  118.         #alex.安装子弹到弹夹中（弹夹，子弹）
  119.         alex.install(gun_jia,gun_dan)
  120.  
  121.     #7.alex把弹夹安装到枪中
  122.     #alex.安装弹夹到枪(枪，弹夹)
  123.     alex.install2(ak47,gun_jia)
  124.  
  125.     #test1:测试弹夹的信息
  126.     print(gun_jia)
  127.  
  128.     #test2:测试枪的信息
  129.     print(ak47)
  130.  
  131.     #8.alex拿枪
  132.     #alex.拿枪（枪）
  133.     alex.catch(ak47)
  134.  
  135.     #test3.测试老王对象
  136.     print(alex)
  137.  
  138.     #5.创建一个敌人
  139.     jack = Person("jack")
  140.     print(jack)
  141.  
  142.     #9.alex拿枪打jack
  143.     #老王.扣扳机（jack）
  144.     for i in range(12):
  145.         alex.pull(jack)
  146.         print(jack)
  147.         print(alex)
  148.  
  149. if __name__ == "__main__":
  150.     main()
  1. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:6/20
  2. jack的血量是0,他没有枪..
  3. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:5/20
  4. jack他挂了...
  5. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:4/20
  6. jack他挂了...
  7. alex的血量是:100,他有枪,枪的信息为:AK47,弹夹的信息为:弹夹的信息为:3/20

day 6 老王开枪打人的更多相关文章

  1. day_5.12 py 老王开枪demo

    ps:2018-7-24 21:00:04 其实这部分主要是面向对象的复习!而不是面向过程 #!/usr/bin/env/python #-*-coding:utf-8-*- ''' 2018-5-1 ...

  2. python 案例之老王开枪

  3. Python---老王开枪

    class Person(object): """人类""" def __init__(self,name): super(Person,s ...

  4. Java 的锁-老王女儿的爱情

    对象锁: new一个对象,都会给这个实例创建一把锁,对象中的方法必须在实例创建后,通过调用方法获取锁,一个线程进去这个方法之前拿到对象的锁,才能调用方法,否则被阻塞,举个例子,老王有个如花似玉的女儿, ...

  5. 老王教您怎么做cass7.1 8.0 9.1所有系列的复制狗 加密狗 破解狗

    cass7.1 8.0 9.1所有系列的复制狗 加密狗 破解狗本来是出于好奇看到网上有这样的东西,学了下感觉挺简单的,如果你是cass的初学者想仅仅是想学习这个软件,不想花大价格购买正版的,这个是可以 ...

  6. 老王Python培训视频教程（价值500元）【基础进阶项目篇 – 完整版】

    老王Python培训视频教程(价值500元)[基础进阶项目篇 – 完整版] 教学大纲python基础篇1-25课时1.虚拟机安装ubuntu开发环境,第一个程序:hello python! (配置开发 ...

  7. javascript 老王开车去东北

    [Decode error - output not utf-8] 魔女 飞 奔驰 去 华南 [Finished in 1.1s] 需要变化的对象进行隔离.正是编程的乐趣之处 /** * by Jac ...

  8. python开发之路：python数据类型（老王版）

    python开发之路:python数据类型 你辞职当了某类似微博的社交网站的底层python开发主管,官还算高. 一次老板让你编写一个登陆的程序.咔嚓,编出来了.执行一看,我的妈,报错? 这次你又让媳 ...

  9. python之路：变量与变量基本操作（老王版）

    python开发之路:变量与变量基本操作 你是一个师范大学的优秀毕业生,现在在某某小学工作. 你想:判作业真的很累,隔壁老王现在天天玩<蓝月传奇>,银行里存满了钱.唉,每节课1个小时,每个 ...

随机推荐

  1. NPM cache相关

    今天下午把package.lock.json用别人的替换了,然后编译一堆报错,这个问题弄了一下午. 总结一下经验: 1.关于npm cache NPM会把所有下载的包保存,放在用户文件夹下面,在我的w ...

  2. 牛客网多校训练第一场 D - Two Graphs

    链接: https://www.nowcoder.com/acm/contest/139/D 题意: 两个无向简单图都有n(1≤n≤8)个顶点,图G1有m1条边,图G2有m2条边,问G2有多少个子图与 ...

  3. poj 1159 Palindrome 【LCS】

    任意门:http://poj.org/problem?id=1159 解题思路: LCS + 滚动数组 AC code: #include <cstdio> #include <io ...

  4. Linux入门基础介绍

    概述: 1. linux是一个开源.免费的操作系统,其稳定性.安全性.处理多并发已经得到业界的认可,目前很多企业级的项目        都会部署到Linux/unix系统上. 2. 常见的操作系统(w ...

  5. P1018 乘积最大(高精度加/乘)

    P1018 乘积最大 一道dp题目.比较好像的dp题目. 然而他需要高精度计算. 所以,他从我开始学oi,到现在.一直是60分的状态. 今天正打算复习模板.也就有借口解决了这道题目. #include ...

  6. HTML5前端性能优化——浏览器兼容与前端性能优化

    一.浏览器兼容 1.1.概要 世界上没有任何一个浏览器是一样的,同样的代码在不一样的浏览器上运行就存在兼容性问题.不同浏览器其内核亦不尽相同,相同内核的版本不同,相同版本的内核浏览器品牌不一样,各种运 ...

  7. jquery固定位置浮动

    示例: <!DOCTYPE html> <html> <head> <title>test page</title> <script ...

  8. TCP/IP初识（一）

    TCP/IP学习记录,如有错误请指正,谢谢!!! 什么是TCP/IP协议? TCP/IP协议族分为四层(另一个名字是Internet协议族(Internet Protocol Suite)):链路层. ...

  9. #leetcode刷题之路13-罗马数字转整数

    罗马数字包含以下七种字符: I, V, X, L,C,D 和 M.字符 数值I 1V 5X 10L 50C 100D 500M 1000例如, 罗马数字 2 写做 II ,即为两个并列的 1.12 写 ...

  10. linux系统基础之-----磁盘结构（基于centos7.4 1708）