面向对象依赖组合小练习

练习

暴力摩托程序（完成下列需求）：
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)

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

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()

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

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))

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

学校类要求：
- 学校类封装学校名称，学校地址，以及相关老师（以列表形式存放老师对象）的属性。
  - 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)

面向对象依赖组合小练习

练习

猜你喜欢