面向对象依赖组合小练习

练习

1. 暴力摩托程序（完成下列需求）：

   1. 创建三个游戏人物，分别是：

      ​ 苍井井，女，18，攻击力ad为20，血量200

      ​ 东尼木木，男，20，攻击力ad为30，血量150

      ​ 波多多，女，19，攻击力ad为50，血量80

   2. 创建三个游戏武器，分别是：

      平底锅，ad为20

      ​ 斧子，ad为50

      ​ 双节棍，ad为65

   3. 创建三个游戏摩托车，分别是：

​ 小踏板，速度60迈

​ 雅马哈，速度80迈

​ 宝马，速度120迈。

​ 完成下列需求（利用武器打人掉的血量为武器的ad + 人的ad）：

​ （1）苍井井骑着小踏板开着60迈的车行驶在赛道上。

​ （2）东尼木木骑着宝马开着120迈的车行驶在赛道上。

​ （3）波多多骑着雅马哈开着80迈的车行驶在赛道上。

​ （4）苍井井赤手空拳打了波多多20滴血，波多多还剩xx血。

​ （5）东尼木木赤手空拳打了波多多30滴血，波多多还剩xx血。

​ （6）波多多利用平底锅打了苍井井一平底锅，苍井井还剩xx血。

​ （7）波多多利用斧子打了东尼木木一斧子，东尼木木还剩xx血。

​ （8）苍井井骑着宝马打了骑着小踏板的东尼木木一双节棍，东尼木木哭了，还剩xx血。（选做）

​ （9）波多多骑着小踏板打了骑着雅马哈的东尼木木一斧子，东尼木木哭了，还剩xx血。（选做）

class Role:

    def __init__(self,name,sex,age,ad,blood):
        self.name = name
        self.sex = sex
        self.age = age
        self.ad = ad
        self.blood = blood

    def fight(self, beaten):
        beaten.blood -= self.ad
        print(f"{self.name}赤手空拳大了{beaten.name}{self.ad}滴血,{beaten.name}还剩下{beaten.blood}")
    def fight2(self,beaten):
        beaten.blood -= self.ad + self.weapon.ad
        print(f"{self.name}骑着{self.motorcycle.name}打了骑着{beaten.motorcycle.name}的{beaten.name}一{self.weapon.name},{beaten.name}哭了,还剩{beaten.blood}")

class Weapon:

    def __init__(self,name,ad):
        self.name = name
        self.ad = ad

    def finght(self,p1,p2):
        p2.blood -= p1.ad +self.ad
        print(f"{p1.name}利用{self.name}打了{p2.name}一{self.name},{p2.name}还剩{p2.blood}血")

class Motorcycle:

    def __init__(self,name,speed):
        self.name = name
        self.speed = speed

    def drving(self,who):
        print(f"{who.name}骑着{self.name}开着{self.speed}迈的车行驶在赛道上.")

cjj = Role("苍井井","女",18,20,200)
dnmm = Role("东尼木木","男",20,30,150)
bdd = Role("波多多","女",19,50,80)

pdg = Weapon("平底锅",20)
fz = Weapon("斧子",50)
sjg = Weapon("双截棍",65)

xtb = Motorcycle("小踏板",60)
ymh = Motorcycle("雅马哈",80)
bm = Motorcycle("宝马",120)

cjj.motorcycle = xtb
dnmm.motorcycle = bm
bdd.motorcycle = ymh

cjj.motorcycle.drving(cjj)
dnmm.motorcycle.drving(dnmm)
bdd.motorcycle.drving(bdd)

cjj.fight(bdd)
dnmm.fight(bdd)

bdd.weapon = pdg
bdd.weapon.finght(bdd,cjj)
bdd.weapon = fz
bdd.weapon.finght(bdd,dnmm)

cjj.motorcycle = bm
cjj.weapon = sjg
dnmm.motorcycle = xtb

cjj.fight2(dnmm)
bdd.motorcycle = xtb
bdd.weapon = fz
dnmm.motorcycle =ymh
bdd.fight2(dnmm)

2. 定义一个类，计算圆的周长和面积。

   class Circular:
   
       pi = 3.14159
   
       def __init__(self,radius):
           self.radius =radius
       def girth(self):
           print(Circular.pi*self.radius*2)
   
       def area(self):
           print(Circular.pi*self.radius**2)
   s = Circular(3)
   s.girth()
   s.area()
   

3. 定义一个圆环类，计算圆环的周长和面积（升级题）。

   class Ring:
       pi = 3.14159
   
       def __init__(self, radius,radius1):
           self.radius = radius
           self.radius1 = radius1
   
       def girth(self):
           print(Ring.pi * self.radius * 2+Ring.pi * self.radius1 * 2)
   
       def area(self):
           print(abs(Ring.pi * self.radius ** 2-Ring.pi * self.radius1 ** 2))
   

4. 定义一个学校类，一个老师类。

• 学校类要求：
  • 学校类封装学校名称，学校地址，以及相关老师（以列表形式存放老师对象）的属性。
    • name: 学校名称。
    • address: 具体地址。
    • teacher_list: []。
  • 学校类设置添加老师对象的方法。
• 老师类封装姓名，教授学科，以及所属学校的具体对象。
  • name: 老师名。
  • course: 学科。
  • school: 具体学校对象。
• 实例化2个校区：
  • 北京校区，美丽的沙河；
  • 深圳校区，南山区。
• 实例化6个老师：
  • 太白，Python, 北京校区对象。
  • 吴超，linux, 北京校区对象。
  • 宝元，python, 北京校区对象。
  • 苑昊，python, 深圳校区对象。
  • 小虎，linux, 深圳校区对象。
  • 小王，Python，深圳校区对象。
• 完成以下具体需求：
  1. 获取太白所属学校名称。
  2. 获取太白所属学校的学校地址。
  3. 将所有属于北京校区的所有老师名展示出来，并添加到一个列表中。
  4. 将所有属于深圳校区的所有老师以及所负责的学科展示出来。
  5. 将两个校区的负责Python学科的所有老师对象添加到一个列表中。
  6. 将两个校区的负责linux学科的所有老师对象添加到一个列表中并循环展示出来。
  7. 将北京校区这个对象利用pickle写入文件中，然后读取出来，并展示出所属于北京校区的老师姓名

class School:

    def __init__(self,name,address):
        self.name = name
        self.address =address
        self.teacher_list=[]

    def recruit(self,teacher):
        self.teacher_list.append(teacher)
        # teacher.school = self

class Teacher:

    def __init__(self,name,course,school):
        self.name = name
        self.course = course
        self.school = school
        self.school.recruit(self)

bj = School("北京校区","美丽的沙河")
sz = School("深圳校区","南山区")

taibai = Teacher("太白","python",bj)
wuchao= Teacher("吴超","linux",bj)
baoyuan = Teacher("宝元","python",bj)
yuanhao = Teacher("苑昊","python",sz)
xiaohu = Teacher("小虎","linux",sz)
xiaowang = Teacher("小王","python",sz)

print(taibai.school.name)

print(taibai.school.address)

lst = []
for i in bj.teacher_list:
    print(i.name)
    lst.append(i.name)
print(lst)

for i in sz.teacher_list:
    print(F"{i.name}负责{i.course}")

lst1 = list(filter(lambda x:x.course=="python" ,bj.teacher_list))+list(filter(lambda x:x.course=="python" ,sz.teacher_list))

for i in lst1:
    print(i.name)

lst2 = list(filter(lambda x:x.course=="linux" ,bj.teacher_list))+list(filter(lambda x:x.course=="linux" ,sz.teacher_list))

for i in lst2:
    print(i)

import pickle
# pickle.dump(bj,open("txt","wb"))
l = pickle.load(open("txt","rb"))

for i in l.teacher_list:
    print(i.name)