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

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

原文地址：https://www.cnblogs.com/liubing8/p/11308127.html

时间： 2024-10-19 22:13:21

Python面向对象02/类的空间问题的相关文章

python 面向对象和类成员和异常处理

python 面向对象 你把自己想象成一个上帝,你要创造一个星球,首先你要把它揉成一个个球,两个直径就能创造一个球 class star: '''名字(name),赤道直径(equatorial diameter),极直径(polar diameter)''' def __init__(self,name,eqDiameter,poDiameter): self.name=name self.eqDiameter=eqDiameter #赤道直径 self.poDiameter=poDiamet

Python 面向对象(创建类和对象，面向对象的三大特性是指：封装、继承和多态，多态性)

概念:                                                                                                                                                     ·        面向过程:根据业务逻辑从上到下写垒代码 ·        函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 ·        面向对象:对函数进行分类和封装,

python面向对象，类

1:类和对象 是面向对象中的俩个重要概念,类是对事物的抽象,比如人类,球类.对象是事物的实例,比如足球,篮球.球类可以对球的特征和行为进行抽象,然后可以实例化一个真实的球体出来. 2:类的定义 类把需要的变量和函数组合成一起,这种包含称为"封装"..classA(object): 3:类的结构 class类名: 成员变量-属性              ## 类的属性是对数据的封装 成员函数-方法              ## 类的方法是对类的行为进行封装 类的创建: class M

Python 面向对象编程——类和实例

1        面向对象编程 面向对象编程: 面向对象编程--Object OrientedProgramming OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数. 面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行.为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统的复杂度. 面向对象的程序设计把计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理这些消息,计算机程序的执行就是一系列消

python 面向对象的类

参考<learn python hard way> 网址:https://learnpythonthehardway.org/book/ex41.html class X(Y) "Make a class named X that is-a Y." 创建一个叫x的类,类x是y(类x 继承y),例如'三文鱼'是'鱼' class X(object): def __init__(self, J) "class X has-a __init__ that takes s

python 面向对象六 类属性和实例属性

一.实例属性 Python是动态语言,根据类创建的实例可以任意绑定属性. 1 >>> class Student(object): 2 ... def __init__(self, name): 3 ... self.name = name # 每个实例必须的属性 4 ... 5 >>> s = Student('Jack') 6 >>> s.score = 90 # 任意绑定属性 7 >>> s.name 8 'Jack' 9 &g

python 面向对象：类，作用域

类(Class)和实例(Instance) 定义类是通过class关键字:class Student(object): pass class后面紧接着是类名,即Student接着是(object),表示该类是从哪个类继承下来的 根据Student类创建出Student的实例,创建实例是通过类名+()实现的:>>> bart = Student() class Student(object): def __init__(self, name, score): self.name = nam

python面向对象-4类的继承与方法的重载

1.类的继承与方法的重载 上面就是先定义了一个类A,然后由定义了一个类B,B继承了类A,这样B就有了A的非私有属性和方法. 1 class Washer: 2 company='ZBL' 3 def __init__(self,water=10,scour=2): 4 self._water=water #不想让用户直接访问实例变量,可以标志成私有 5 self.scour=scour 6 self.year=2000#这是生产日期 7 #属性包装,将water属性包装成方法,用户使用water

python面向对象（类的继承）

一. 继承的初识 在python3中 所有的类都继承自object class ParentClass1: pass class ParentClass2: pass class ChildClass(ParentClass1):pass #单继承 class ChildClass1(ParentClass1,ParentClass2):pass #多继承 print(ParentClass1.__base__) print(ChildClass.__base__) #会显示该类的一个父类 pr