Python面向对象02/类的空间问题

Posted 2022-06-14 liubing8

Python面向对象02/类的空间问题

内容大纲

1.从空间角度研究类

2..类与类之间的关系

1.类的空间问题

1.1何处可以添加对象属性

在类的__init__可以添加,在类的方法也可以添加,在类的外部也可以添加
# class Human:
#
#     mind = '有思想的'
#
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def eat(self,argv):
#         # self.hobby = '女'
#         Human.body = argv
#         print('吃饭')
#
#
# sun = Human('二狗', 18)
sun.eat()
print(sun.__dict__)
sun.weight = 130
print(sun.__dict__)

1.2何处可以添加类的属性

# 类的内部
# sun.eat('有头有脸')
# 类的外部
# Human.body = '有头四肢'
# print(Human.__dict__)

2.类与对象之间的关系

#对象空间与类空间有相同的名字, 对象. 肯定先从对象空间查找.
#查询顺序:  
#   对象.名字: 对象空间  ______类对象指针_______--> 类空间 ---> 父类空间
#   类名.名字: 类空间 -----> 父类空间
#1.每个对象都可以从类的空间去找,不可以去别的对象空间去找
#2.单向不可逆,类名不可以找到对象的属性
#3.__init__产生对象空间,不是空的,有一个对象指针

3.类与类之间的关系

3.1依赖关系

#将一个类的类名或者对象传入另一类的方法中
#class Elephant:
#    def __init__(self,name):
#        self.name = name
#    def open(self,obj):
#        print(f'self.name 默念三声: 3,2,1 开门')
#        obj.be_open()
#    def close(self):
#        print(f'self.name 默念三声: 3,2,1 关门')
#class Refrigerator:
#    def __init__(self, name):
#        self.name = name
#    def be_open(self):
#       print(f'self.name冰箱 被打开了')
#    def be_close(self):
#        print(f'self.name冰箱 被关闭了')
# 
#qiqi = Elephant('河马')
#haier = Refrigerator('海尔')
#qiqi.open(haier)

3.2组合关系

#将一个类的对象封装到另一个类的对象的属性中
# 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一起烛光晚餐')
#         else:
#             print('吃什么吃')
# ergou = Boy('二狗')
# ergou.have_a_diner()
# ergou = Boy('二狗')
# # 只是给二狗封装了一个属性:girlfriend 为一个字符串的数据
# ergou.girlfriend = '乔'
# ergou.have_a_diner()

# 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.age岁的,self.girlfriend.body的女朋友self.girlfriend.name一起烛光晚餐')
#         else:
#             print('吃什么吃')
#     def girl_skill(self):
#         print(f'self.name的女朋友的技能:')
#         self.girlfriend.skill()
# class Girl:
#     def __init__(self,name,age,body):
#         self.name = name
#         self.age = age
#         self.body=body
#     def skill(self):
#         print(f'self.name 会做饭')
#
# ergou = Boy('二狗')
# qiao = Girl('乔', 58, '小钢炮')
# ergou.girlfriend = qiao
# ergou.have_a_diner()
# ergou.girl_skill()



# class GameRole:
#
#     def __init__(self, name, ad, hp):
#         self.name = name
#         self.ad = ad
#         self.hp = hp
#
#     def attack(self, p1):
#         p1.hp = p1.hp - self.ad
#         print(f"self.name攻击p1.name,谁掉了self.ad血,  还剩p1.hp血")
#         print(f'p1.name的血量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 - self.ad
#         print(f'p1.name利用self.name给了p2.name一下子,p2.name掉了self.ad血,还剩p2.hp血')
#
#
#
# gailun = GameRole('盖伦', 10, 100)
# xin = GameRole('菊花信', 20, 80)
# Sword = Weapon('大宝剑',15)
# Musket = Weapon('长缨枪',30)

# 盖伦利用大宝剑给赵信一下子
# Sword.weapon_attack(gailun, xin)
# 1. 功能虽然实现了,但是逻辑上不合理,应该是人物对象调用方法.主体.
# 2. 游戏人物本身就应该绑定武器属性.



class GameRole:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp
    def attack(self, p1):
        p1.hp = p1.hp - self.ad
        print(f"self.name攻击p1.name,谁掉了self.ad血,  还剩p1.hp血")
        print(f'p1.name的血量p1.hp')
    def equipment_wea(self, wea):
        self.weapon = wea  # 组合关系

class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def weapon_attack(self, p1, p2):  # 依赖关系
        print(f'self---->: self')  # self 永远默认接受本类实例化对象
        p2.hp = p2.hp - self.ad
        print(f'p1.name利用self.name给了p2.name一下子,p2.name掉了self.ad血,还剩p2.hp血')

gailun = GameRole('盖伦', 10, 100)
xin = GameRole('阿信', 20, 80)
Sword = Weapon('大剑',15)
Musket = Weapon('长缨枪',30)

# 给游戏人物封装武器属性
gailun.equipment_wea(Sword)
# print(gailun.__dict__)
# gailun.weapon.weapon_attack()
# print(f'gailun:  ---> gailun')
# print(f'Sord:  ---> Sword')
gailun.weapon.weapon_attack(gailun,xin)

4.今日总结

self永远默认接收本类实例化对象
依赖与组合让类与类产生关系,增强耦合性

5.今日练习

# 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 Person:
#     def __init__(self,name,sex,age,ad,hp):
#         self.name = name
#         self.sex = sex
#         self.age = age
#         self.ad = ad
#         self.hp = hp
#     def d_car(self,car):
#         self.car = car
#         print(f'self.name骑着car.name开着car.speed迈的车行驶在赛道上。')
#     def person_attack(self,p1):
#         p1.hp -= self.ad
#         print(f'self.name赤手空拳打了p1.nameself.ad滴血，p1.name还剩p1.hp血')
#
#     def wea_sttack(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一self.name，p2.name还剩p2.hp血。')
#
#     def toatl_attack(self,p1,p2,c1,c2):
#         p2.hp = p2.hp - p1.ad - self.ad
#         print(f'p1.name骑着c1.name打了骑着c2.name的p2.name一self.name，p2.name哭了，还剩p2.hp血。')
# class Car:
#     def __init__(self,name,speed):
#         self.name = name
#         self.speed = speed
#
# cang = Person("苍井井","女",18,20,200)
# dong = Person("东尼木木","男",20,30,150)
# bo = Person("波多多","女",19,50,80)
#
# pan = Weapon("平底锅",20)
# axe = Weapon("斧子",50)
# nunchakus = Weapon("双节棍",65)
#
# small_pedal = Car("小踏板",60)
# yamaha = Car("雅马哈",80)
# bwm = Car("宝马",120)

# cang.d_car(small_pedal)
# dong.d_car(bwm)
# bo.d_car(yamaha)
#
# cang.person_attack(bo)
# dong.person_attack(bo)

# bo.wea_sttack(pan)
# bo.wea.weapon_attack(bo,cang)
# bo.wea_sttack(axe)
# bo.wea.weapon_attack(bo,dong)

# cang.wea_sttack(bwm)
# dong.wea_sttack(small_pedal)
# nunchakus.toatl_attack(cang,dong,cang.wea,dong.wea)
# bo.wea_sttack(pan)
# dong.wea_sttack(yamaha)
# axe.toatl_attack(cang,dong,bo.wea,dong.wea)
#
#
# 2.定义一个类，计算圆的周长和面积。
# class Round:
#     def __init__(self,r):
#         self.r = r
#     def perimeter(self):
#         print(2*3.14*self.r)
#     def area(self):
#         print(3.14*self.r**2)
# obj = Round(3)
# obj.perimeter()
# obj.area()
#
# 3.定义一个圆环类，计算圆环的周长和面积（升级题）。
# class Ring:
#     def __init__(self,r1,r2):
#         self.r1 = r1
#         self.r2 = r2
#     def perimeter(self):
#         print(2*3.14*(self.r2+self.r1))
#     def area(self):
#         print(3.14*(self.r2**2-self.r1**2))
# obj = Ring(4,5)
# obj.perimeter()
# obj.area()
#
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 add_teacher_object(self,obj):
#         self.teacher_list.append(obj)
#
# class Teacher:
#     def __init__(self, name, course, school_object):
#         self.name = name
#         self.course = course
#         self.school = school_object
#
# school1 = School("北京校区","美丽的沙河")
# school2 = School("深圳校区","南山区")
#
# taibai = Teacher("太白","Python",school1)
# wuchao = Teacher("吴超","linux",school1)
# baoyuan = Teacher("宝元","Python",school1)
# yuanhao = Teacher("苑昊","Python",school2)
# xiaohu = Teacher("小虎","linux",school2)
# xiaowang = Teacher("小王","Python",school2)
#
# school1.add_teacher_object(taibai)
# school1.add_teacher_object(wuchao)
# school1.add_teacher_object(baoyuan)
#
# school2.add_teacher_object(yuanhao)
# school2.add_teacher_object(xiaohu)
# school2.add_teacher_object(xiaowang)

# print(taibai.school.name)
# print(taibai.school.address)

# 3.将所有属于北京校区的所有老师名展示出来，并添加到一个列表中。
# lst = []
# for i in school1.teacher_list:
#     print(i.name)
#     lst.append(i.name)
# print(lst)
#
# 4.将所有属于深圳校区的所有老师以及所负责的学科展示出来。
# for i in school2.teacher_list:
#     print(f'i.name老师负责i.course学科')

# 5.将两个校区的负责Python学科的所有老师对象添加到一个列表中。
# lst2 = []
# for i in school2.teacher_list + school1.teacher_list:
#     if i.course == "Python":
#         lst2.append(i.name)
# print(lst2)
#
# 6.将两个校区的负责linux学科的所有老师对象添加到一个列表中并循环展示出来。
# lst3 = []
# for i in school2.teacher_list + school1.teacher_list:
#     if i.course == "linux":
#         lst2.append(i.name)
# print(lst3)
# for i in lst3:
#     print(i)

# 7.将北京校区这个对象利用pickle写入文件中，然后读取出来，并展示出所属于北京校区的老师姓名。
# import pickle
# pickle.dump(school1,open("text1","wb"))
# obj = pickle.load(open("text1","rb"))
# for i in obj.teacher_list:
#     print(i.name)