标签：计算 产生 有一个 res obb 面向 读取 tac tor
1.从空间角度研究类
2..类与类之间的关系
在类的__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__)# 类的内部
# sun.eat('有头有脸')
# 类的外部
# Human.body = '有头四肢'
# print(Human.__dict__)#对象空间与类空间有相同的名字, 对象. 肯定先从对象空间查找.
#查询顺序:
# 对象.名字: 对象空间 ______类对象指针_______--> 类空间 ---> 父类空间
# 类名.名字: 类空间 -----> 父类空间
#1.每个对象都可以从类的空间去找,不可以去别的对象空间去找
#2.单向不可逆,类名不可以找到对象的属性
#3.__init__产生对象空间,不是空的,有一个对象指针
#将一个类的类名或者对象传入另一类的方法中
#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)#将一个类的对象封装到另一个类的对象的属性中
# 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)
self永远默认接收本类实例化对象
依赖与组合让类与类产生关系,增强耦合性# 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.name}{self.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)标签：计算 产生 有一个 res obb 面向 读取 tac tor
原文地址：https://www.cnblogs.com/liubing8/p/11308127.html
